shipit-cli 0.8.0__tar.gz → 0.9.0__tar.gz

{shipit_cli-0.8.0 → shipit_cli-0.9.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: shipit-cli
-Version: 0.8.0
-Summary: Add your description here
+Version: 0.9.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
 Project-URL: Changelog, https://github.com/wasmerio/shipit/changelog
@@ -10,6 +10,7 @@ Requires-Dist: dotenv>=0.9.9
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: requests>=2.32.5
 Requires-Dist: rich>=14.1.0
+Requires-Dist: semantic-version>=2.10.0
 Requires-Dist: sh>=2.2.2
 Requires-Dist: starlark-pyo3>=2025.1
 Requires-Dist: tomlkit>=0.13.3

{shipit_cli-0.8.0 → shipit_cli-0.9.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "shipit-cli"
-version = "0.8.0"
-description = "Add your description here"
+version = "0.9.0"
+description = "Shipit CLI is the best way to build, serve and deploy your projects anywhere."
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
@@ -9,6 +9,7 @@ dependencies = [
     "pyyaml>=6.0.2",
     "requests>=2.32.5",
     "rich>=14.1.0",
+    "semantic-version>=2.10.0",
     "sh>=2.2.2",
     "starlark-pyo3>=2025.1",
     "tomlkit>=0.13.3",
@@ -36,7 +37,7 @@ only-include = ["src/shipit", "tests"]
 [tool.uv]
 dev-dependencies = [
     "aiohttp>=3.12.15",
-    "pytest>=8.2",
+    "pytest>=8.4.1",
     "pytest-asyncio>=1.2.0",
     "pytest-rerunfailures>=16.0.1",
     "pytest-xdist>=3.8.0",

{shipit_cli-0.8.0 → shipit_cli-0.9.0}/src/shipit/cli.py

@@ -305,7 +305,7 @@ class DockerBuilder:
             image_name,
             command,
             *(extra_args or []),
-            _env=os.environ,  # Pass the current environment variables to the Docker client
+            _env={"DOCKER_BUILDKIT": "1", **os.environ},  # Pass the current environment variables to the Docker client
             _out=write_stdout,
             _err=write_stderr,
         )
@@ -370,7 +370,8 @@ RUN chmod {oct(mode)[2:]} {path.absolute()}
         base_path = self.docker_path
         shutil.rmtree(base_path, ignore_errors=True)
         base_path.mkdir(parents=True, exist_ok=True)
-        self.docker_file_contents = "FROM debian:trixie-slim AS build\n"
+        self.docker_file_contents = "# syntax=docker/dockerfile:1.7-labs\n"
+        self.docker_file_contents += "FROM debian:trixie-slim AS build\n"
 
         self.docker_file_contents += """
 RUN apt-get update \\
@@ -378,6 +379,8 @@ RUN apt-get update \\
         build-essential gcc make autoconf libtool bison \\
         dpkg-dev pkg-config re2c locate \\
         libmariadb-dev libmariadb-dev-compat libpq-dev \\
+        libvips-dev default-libmysqlclient-dev libmagickwand-dev \\
+        libicu-dev libxml2-dev libxslt-dev \\
         sudo curl ca-certificates \\
     && rm -rf /var/lib/apt/lists/*
 
@@ -435,7 +438,11 @@ RUN curl https://mise.run | sh
                     else:
                         raise Exception(f"Asset {step.source} does not exist")
                 else:
-                    self.docker_file_contents += f"COPY {step.source} {step.target}\n"
+                    if step.ignore:
+                        exclude = " \\\n" +" \\\n".join([f"  --exclude={ignore}" for ignore in step.ignore]) + " \\\n "
+                    else:
+                        exclude = ""
+                    self.docker_file_contents += f"COPY{exclude} {step.source} {step.target}\n"
             elif isinstance(step, EnvStep):
                 env_vars = " ".join(
                     [f"{key}={value}" for key, value in step.variables.items()]
@@ -538,9 +545,10 @@ class LocalBuilder:
             exe = shutil.which(program, path=PATH)
             if not exe:
                 raise Exception(f"Program is not installed: {program}")
-            cmd = sh.Command(exe)  # "grep"
+            cmd = sh.Command("bash")  # "grep"
             result = cmd(
-                *parts[1:],
+                "-c",
+                command_line,
                 _env={**env, "PATH": PATH},
                 _cwd=build_path,
                 _out=write_stdout,

shipit_cli-0.9.0/src/shipit/providers/node_static.py

@@ -0,0 +1,304 @@
+from __future__ import annotations
+
+import json
+import yaml
+from pathlib import Path
+from typing import Dict, Optional, Any, Set
+from enum import Enum
+from semantic_version import Version, NpmSpec
+
+
+from .base import (
+    DetectResult,
+    DependencySpec,
+    Provider,
+    _exists,
+    MountSpec,
+    ServiceSpec,
+    VolumeSpec,
+    CustomCommands,
+)
+from .staticfile import StaticFileProvider
+
+
+class PackageManager(Enum):
+    NPM = "npm"
+    PNPM = "pnpm"
+    YARN = "yarn"
+    BUN = "bun"
+
+    def as_dependency(self, path) -> DependencySpec:
+        dep_name = {
+            PackageManager.NPM: "npm",
+            PackageManager.PNPM: "pnpm",
+            PackageManager.YARN:  "yarn",
+            PackageManager.BUN: "bun",
+        }[self]
+
+        default_version = None
+        if self == PackageManager.PNPM:
+            lockfile = path / self.lockfile()
+            lockfile_version = self.pnpm_lockfile_version(lockfile)
+            if lockfile_version:
+                if lockfile_version.startswith("5."):
+                    default_version = "7"
+                elif lockfile_version.startswith("6."):
+                    default_version = "8"
+
+        return DependencySpec(
+            dep_name,
+            env_var=f"SHIPIT_{dep_name.upper()}_VERSION",
+            default_version=default_version,
+        )
+
+    def lockfile(self) -> (str):
+        return {
+            PackageManager.NPM: "package-lock.json",
+            PackageManager.PNPM: "pnpm-lock.yaml",
+            PackageManager.YARN: "yarn.lock",
+            PackageManager.BUN: "bun.lockb",
+        }[self]
+    
+    @classmethod
+    def pnpm_lockfile_version(cls, lockfile: Path) -> Optional[str]:
+        # Read line by line and return the lockfileVersion
+        with open(lockfile, "r") as f:
+            for line in f:
+                if "lockfileVersion" in line:
+                    try:
+                        config = yaml.safe_load(line)
+                        version = config.get("lockfileVersion")
+                        assert isinstance(version, (str, bytes))
+                        return version
+                    except:
+                        pass
+        return None
+
+    def install_command(self, has_lockfile: bool = False) -> str:
+        return {
+            PackageManager.NPM: f"npm {'ci' if has_lockfile else 'install'}",
+            PackageManager.PNPM: f"pnpm install{' --frozen-lockfile' if has_lockfile else ''}",
+            PackageManager.YARN: f"yarn install{' --frozen-lockfile' if has_lockfile else ''}",
+            PackageManager.BUN: f"bun install{' --no-save' if has_lockfile else ''}",
+        }[self]
+
+    def run_command(self, command: str) -> str:
+        return {
+            PackageManager.NPM: f"npm run {command}",
+            PackageManager.PNPM: f"pnpm run {command}",
+            PackageManager.YARN: f"yarn run {command}",
+            PackageManager.BUN: f"bun run {command}",
+        }[self]
+
+    def run_execute_command(self, command: str) -> str:
+        return {
+            PackageManager.NPM: f"npx {command}",
+            PackageManager.PNPM: f"pnpx {command}",
+            PackageManager.YARN: f"ypx {command}",
+            PackageManager.BUN: f"bunx {command}",
+        }[self]
+
+
+class StaticGenerator(Enum):
+    ASTRO = "astro"
+    VITE = "vite"
+    NEXT = "next"
+    GATSBY = "gatsby"
+    DOCUSAURUS = "docusaurus"
+    SVELTE = "svelte"
+    REMIX = "remix"
+    NUXT_OLD = "nuxt"
+    NUXT_V3 = "nuxt3"
+
+
+class NodeStaticProvider(StaticFileProvider):
+    package_manager: PackageManager
+    package_json: Optional[Dict[str, Any]]
+    extra_dependencies: Set[str]
+
+    def __init__(self, path: Path, custom_commands: CustomCommands):
+        super().__init__(path, custom_commands)
+        if (path / "package-lock.json").exists():
+            self.package_manager = PackageManager.NPM
+        elif (path / "pnpm-lock.yaml").exists():
+            self.package_manager = PackageManager.PNPM
+        elif (path / "yarn.lock").exists():
+            self.package_manager = PackageManager.YARN
+        elif (path / "bun.lockb").exists():
+            self.package_manager = PackageManager.BUN
+        else:
+            self.package_manager = PackageManager.PNPM
+
+        self.package_json = self.parse_package_json(path)
+
+        if self.has_dependency(self.package_json, "gatsby"):
+            self.static_generator = StaticGenerator.GATSBY
+        elif self.has_dependency(self.package_json, "astro"):
+            self.static_generator = StaticGenerator.ASTRO
+        elif self.has_dependency(self.package_json, "@docusaurus/core"):
+            self.static_generator = StaticGenerator.DOCUSAURUS
+        elif self.has_dependency(self.package_json, "svelte"):
+            self.static_generator = StaticGenerator.SVELTE
+        elif self.has_dependency(self.package_json, "@remix-run/dev"):
+            self.static_generator = StaticGenerator.REMIX
+        elif self.has_dependency(self.package_json, "vite"):
+            self.static_generator = StaticGenerator.VITE
+        elif self.has_dependency(self.package_json, "next"):
+            self.static_generator = StaticGenerator.NEXT
+        elif self.has_dependency(self.package_json, "nuxt", "2") or self.has_dependency(
+            self.package_json, "nuxt", "1"
+        ):
+            self.static_generator = StaticGenerator.NUXT_OLD
+        elif self.has_dependency(self.package_json, "nuxt"):
+            self.static_generator = StaticGenerator.NUXT_V3
+        
+        # if self.has_dependency(self.package_json, "sharp"):
+        #     self.extra_dependencies.add("libvips")
+
+    @classmethod
+    def parse_package_json(cls, path: Path) -> Optional[Dict[str, Any]]:
+        package_json_path = path / "package.json"
+        if not package_json_path.exists():
+            return None
+        try:
+            package_json = json.loads(package_json_path.read_text())
+            assert isinstance(package_json, dict), (
+                "package.json must be a valid JSON object"
+            )
+            return package_json
+        except Exception:
+            return None
+
+    @classmethod
+    def has_dependency(
+        cls, package_json: Optional[Dict[str, Any]], dep: str, version: Optional[str] = None
+    ) -> bool:
+        if not package_json:
+            return False
+        for section in ("dependencies", "devDependencies", "peerDependencies"):
+            dep_section = package_json.get(section, {})
+            if dep in dep_section:
+                if version:
+                    try:
+                        constraint = NpmSpec(dep_section[dep])
+                        return Version(version) in constraint
+                    except Exception:
+                        pass
+                else:
+                    return True
+        return False
+
+    @classmethod
+    def name(cls) -> str:
+        return "node-static"
+
+    @classmethod
+    def detect(
+        cls, path: Path, custom_commands: CustomCommands
+    ) -> Optional[DetectResult]:
+        package_json = cls.parse_package_json(path)
+        if not package_json:
+            return None
+        static_generators = ["astro", "vite", "next", "nuxt", "gatsby", "svelte", "@docusaurus/core", "@remix-run/dev"]
+        if any(cls.has_dependency(package_json, dep) for dep in static_generators):
+            return DetectResult(cls.name(), 40)
+        return None
+
+    def initialize(self) -> None:
+        pass
+
+    def serve_name(self) -> str:
+        return self.path.name
+
+    def provider_kind(self) -> str:
+        return "staticsite"
+
+    def dependencies(self) -> list[DependencySpec]:
+        package_manager_dep = self.package_manager.as_dependency(self.path)
+        package_manager_dep.use_in_build = True
+        return [
+            DependencySpec(
+                "node",
+                env_var="SHIPIT_NODE_VERSION",
+                default_version="22",
+                use_in_build=True,
+            ),
+            package_manager_dep,
+            DependencySpec("static-web-server", use_in_serve=True),
+        ]
+
+    def declarations(self) -> Optional[str]:
+        return None
+
+    def get_output_dir(self) -> str:
+        if self.static_generator == StaticGenerator.NEXT:
+            return "out"
+        elif self.static_generator in [StaticGenerator.ASTRO, StaticGenerator.VITE, StaticGenerator.NUXT_OLD, StaticGenerator.NUXT_V3]:
+            return "dist"
+        elif self.static_generator in [StaticGenerator.GATSBY, StaticGenerator.REMIX]:
+            return "public"
+        elif self.static_generator in [StaticGenerator.DOCUSAURUS, StaticGenerator.SVELTE]:
+            return "build"
+        else:
+            return "dist"
+
+    def get_build_command(self) -> bool:
+        if not self.package_json:
+            return False
+        build_command = self.package_json.get("scripts", {}).get("build")
+        if build_command:
+            return self.package_manager.run_command("build")
+        if self.static_generator == StaticGenerator.GATSBY:
+            return self.package_manager.run_execute_command("gatsby build")
+        if self.static_generator == StaticGenerator.ASTRO:
+            return self.package_manager.run_execute_command("astro build")
+        elif self.static_generator == StaticGenerator.REMIX:
+            return self.package_manager.run_execute_command("remix-ssg build")
+        elif self.static_generator == StaticGenerator.DOCUSAURUS:
+            return self.package_manager.run_execute_command("docusaurus build")
+        elif self.static_generator == StaticGenerator.SVELTE:
+            return self.package_manager.run_execute_command("svelte-kit build")
+        elif self.static_generator == StaticGenerator.VITE:
+            return self.package_manager.run_execute_command("vite build")
+        elif self.static_generator == StaticGenerator.NEXT:
+            return self.package_manager.run_execute_command("next export")
+        elif self.static_generator == StaticGenerator.NUXT_V3:
+            return self.package_manager.run_execute_command("nuxi generate")
+        elif self.static_generator == StaticGenerator.NUXT_OLD:
+            return self.package_manager.run_execute_command("nuxt generate")
+        return False
+
+    def build_steps(self) -> list[str]:
+        output_dir = self.get_output_dir()
+        get_build_command = self.get_build_command()
+        lockfile = self.package_manager.lockfile()
+        has_lockfile = (self.path / lockfile).exists()
+        install_command = self.package_manager.install_command(has_lockfile=has_lockfile)
+        input_files = ["package.json"]
+        if has_lockfile:
+            input_files.append(lockfile)
+        inputs_install_files = ", ".join([f'"{file}"' for file in input_files])
+
+        return [
+            'workdir(temp["build"])',
+            # 'run("npx corepack enable", inputs=["package.json"], group="install")',
+            f'run("{install_command}", inputs=[{inputs_install_files}], group="install")',
+            'copy(".", ".", ignore=["node_modules", ".git"])',
+            f'run("{get_build_command}", outputs=["{output_dir}"], group="build")',
+            f'run("cp -R {output_dir}/* {{}}/".format(app["build"]))',
+        ]
+
+    def prepare_steps(self) -> Optional[list[str]]:
+        return None
+
+    def mounts(self) -> list[MountSpec]:
+        return [MountSpec("temp"), *super().mounts()]
+
+    def volumes(self) -> list[VolumeSpec]:
+        return []
+
+    def env(self) -> Optional[Dict[str, str]]:
+        return None
+
+    def services(self) -> list[ServiceSpec]:
+        return []

{shipit_cli-0.8.0 → shipit_cli-0.9.0}/src/shipit/providers/registry.py

@@ -16,7 +16,7 @@ def providers() -> list[type[Provider]]:
     # Order matters: more specific providers first
     return [
         LaravelProvider,
-        GatsbyProvider,
+        # GatsbyProvider,
         HugoProvider,
         MkdocsProvider,
         PythonProvider,

{shipit_cli-0.8.0 → shipit_cli-0.9.0}/src/shipit/providers/staticfile.py

@@ -19,6 +19,8 @@ from .base import (
 
 class StaticFileProvider:
     config: Optional[dict] = None
+    path: Path
+    custom_commands: CustomCommands
 
     def __init__(self, path: Path, custom_commands: CustomCommands):
         self.path = path

shipit_cli-0.9.0/src/shipit/version.py

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

shipit_cli-0.8.0/src/shipit/providers/node_static.py

@@ -1,88 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Dict, Optional
-
-from .base import (
-    DetectResult,
-    DependencySpec,
-    Provider,
-    _exists,
-    _has_dependency,
-    MountSpec,
-    ServiceSpec,
-    VolumeSpec,
-    CustomCommands,
-)
-
-
-class NodeStaticProvider:
-    def __init__(self, path: Path, custom_commands: CustomCommands):
-        self.path = path
-        self.custom_commands = custom_commands
-
-    @classmethod
-    def name(cls) -> str:
-        return "node-static"
-
-    @classmethod
-    def detect(cls, path: Path, custom_commands: CustomCommands) -> Optional[DetectResult]:
-        pkg = path / "package.json"
-        if not pkg.exists():
-            return None
-        static_generators = ["astro", "vite", "next", "nuxt"]
-        if any(_has_dependency(pkg, dep) for dep in static_generators):
-            return DetectResult(cls.name(), 40)
-        return None
-
-    def initialize(self) -> None:
-        pass
-
-    def serve_name(self) -> str:
-        return self.path.name
-
-    def provider_kind(self) -> str:
-        return "staticsite"
-
-    def dependencies(self) -> list[DependencySpec]:
-        return [
-            DependencySpec(
-                "node",
-                env_var="SHIPIT_NODE_VERSION",
-                default_version="22",
-                use_in_build=True,
-            ),
-            DependencySpec("npm", use_in_build=True),
-            DependencySpec("static-web-server", use_in_serve=True),
-        ]
-
-    def declarations(self) -> Optional[str]:
-        return None
-
-    def build_steps(self) -> list[str]:
-        output_dir = "dist" if (self.path / "dist").exists() else "public"
-        return [
-            "run(\"npm install\", inputs=[\"package.json\", \"package-lock.json\"], group=\"install\")",
-            "copy(\".\", \".\", ignore=[\"node_modules\", \".git\"])",
-            f"run(\"npm run build\", outputs=[\"{output_dir}\"], group=\"build\")",
-            f"run(\"cp -R {output_dir}/* {{}}/\".format(app[\"build\"]))",
-        ]
-
-    def prepare_steps(self) -> Optional[list[str]]:
-        return None
-
-    def commands(self) -> Dict[str, str]:
-        output_dir = "dist" if (self.path / "dist").exists() else "public"
-        return {"start": f'"static-web-server --root /app/{output_dir}"'}
-
-    def mounts(self) -> list[MountSpec]:
-        return [MountSpec("app")]
-
-    def volumes(self) -> list[VolumeSpec]:
-        return []
-
-    def env(self) -> Optional[Dict[str, str]]:
-        return None
-    
-    def services(self) -> list[ServiceSpec]:
-        return []

shipit_cli-0.8.0/src/shipit/version.py

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