shipit-cli 0.7.1__py3-none-any.whl → 0.9.0__py3-none-any.whl

shipit/assets/wordpress/install.sh

@@ -12,7 +12,7 @@ echo "" > wp-content/upgrade/.keep
 
 echo "Installing WordPress core..."
 
-wp-cli core install \
+wp core install \
   --url="$WASMER_APP_URL"  \
   --title="$WP_SITE_TITLE" \
   --admin_user="$WP_ADMIN_USERNAME" \
@@ -21,13 +21,8 @@ wp-cli core install \
   --locale="$WP_LOCALE"
 
 
-if [ -z "$WASMER_FIRST_DEPLOYMENT" ]; then
-    wp-cli core update-db
-fi    
-
-echo "Installing theme..."
-wp-cli wasmer-aio-install install \
-  --locale="$WP_LOCALE" \
-  --theme=twentytwentyfive || true
+if [ -z "$WP_UPDATE_DB" ]; then
+    wp core update-db
+fi
 
 echo "Installation complete"

shipit/cli.py

@@ -148,10 +148,12 @@ class Build:
 
 def write_stdout(line: str) -> None:
     sys.stdout.write(line)  # print to console
+    sys.stdout.flush()
 
 
 def write_stderr(line: str) -> None:
     sys.stderr.write(line)  # print to console
+    sys.stderr.flush()
 
 
 class MapperItem(TypedDict):
@@ -179,6 +181,16 @@ class Builder(Protocol):
 
 
 class DockerBuilder:
+    mise_mapper = {
+        "php": {
+            "source": "ubi:adwinying/php",
+        },
+        "composer": {
+            "source": "ubi:composer/composer",
+            "postinstall": """composer_dir=$(mise where ubi:composer/composer); ln -s "$composer_dir/composer.phar" /usr/local/bin/composer""",
+        },
+    }
+
     def __init__(self, src_dir: Path, docker_client: Optional[str] = None) -> None:
         self.src_dir = src_dir
         self.docker_file_contents = ""
@@ -293,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,
         )
@@ -340,12 +352,17 @@ RUN chmod {oct(mode)[2:]} {path.absolute()}
                 )
             self.docker_file_contents += f"RUN curl --proto '=https' --tlsv1.2 -sSfL https://get.static-web-server.net | sh\n"
             return
+
+        mapped_dependency = self.mise_mapper.get(dependency.name, {})
+        package_name = mapped_dependency.get("source", dependency.name)
         if dependency.version:
             self.docker_file_contents += (
-                f"RUN mise use --global {dependency.name}@{dependency.version}\n"
+                f"RUN mise use --global {package_name}@{dependency.version}\n"
             )
         else:
-            self.docker_file_contents += f"RUN mise use --global {dependency.name}\n"
+            self.docker_file_contents += f"RUN mise use --global {package_name}\n"
+        if mapped_dependency.get("postinstall"):
+            self.docker_file_contents += f"RUN {mapped_dependency.get('postinstall')}\n"
 
     def build(
         self, env: Dict[str, str], mounts: List[Mount], steps: List[Step]
@@ -353,14 +370,17 @@ 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 \\
     && apt-get -y --no-install-recommends install \\
-        build-essential gcc make \\
-        dpkg-dev pkg-config \\
+        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/*
 
@@ -407,7 +427,7 @@ RUN curl https://mise.run | sh
                         # Read the file content and write it to the target file
                         content_base64 = base64.b64encode(
                             (ASSETS_PATH / step.source).read_bytes()
-                        )
+                        ).decode("utf-8")
                         self.docker_file_contents += (
                             f"RUN echo '{content_base64}' | base64 -d > {step.target}\n"
                         )
@@ -418,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()]
@@ -446,12 +470,6 @@ Shipit
     def get_path(self) -> Path:
         return Path("/")
 
-    def get_build_path(self) -> Path:
-        return self.get_path() / "app"
-
-    def get_serve_path(self) -> Path:
-        return self.get_path() / "serve"
-
     def prepare(self, env: Dict[str, str], prepare: List[PrepareStep]) -> None:
         raise NotImplementedError
 
@@ -461,13 +479,12 @@ Shipit
         for dep in serve.deps:
             self.add_dependency(dep)
 
-        build_path = self.get_build_path()
         for command in serve.commands:
             console.print(f"* {command}")
             command_path = serve_command_path / command
             self.create_file(
                 command_path,
-                f"#!/bin/bash\ncd {build_path}\n{serve.commands[command]}",
+                f"#!/bin/bash\ncd {serve.cwd}\n{serve.commands[command]}",
                 mode=0o755,
             )
 
@@ -480,6 +497,7 @@ class LocalBuilder:
     def __init__(self, src_dir: Path) -> None:
         self.src_dir = src_dir
         self.local_path = self.src_dir / ".shipit" / "local"
+        self.serve_bin_path = self.local_path / "serve" / "bin"
         self.prepare_bash_script = self.local_path / "prepare" / "prepare.sh"
         self.build_path = self.local_path / "build"
         self.workdir = self.build_path
@@ -503,6 +521,8 @@ class LocalBuilder:
         elif isinstance(step, WorkdirStep):
             console.print(f"[bold]Working in {step.path}[/bold]")
             self.workdir = step.path
+            # We make sure the dir exists
+            step.path.mkdir(parents=True, exist_ok=True)
         elif isinstance(step, RunStep):
             extra = ""
             if step.inputs:
@@ -525,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,
@@ -628,12 +649,6 @@ class LocalBuilder:
     def get_path(self) -> Path:
         return self.local_path
 
-    def get_build_path(self) -> Path:
-        return self.get_path() / "build"
-
-    def get_serve_path(self) -> Path:
-        return self.get_path() / "serve"
-
     def build_prepare(self, serve: Serve) -> None:
         self.prepare_bash_script.parent.mkdir(parents=True, exist_ok=True)
         commands: List[str] = []
@@ -676,14 +691,13 @@ class LocalBuilder:
     def build_serve(self, serve: Serve) -> None:
         # Remember serve configuration for run-time
         console.print("\n[bold]Building serve[/bold]")
-        serve_command_path = self.get_serve_path() / "bin"
-        serve_command_path.mkdir(parents=True, exist_ok=False)
+        self.serve_bin_path.mkdir(parents=True, exist_ok=False)
         path = self.get_path() / ".path"
         path_text = path.read_text()
         console.print(f"[bold]Serve Commands:[/bold]")
         for command in serve.commands:
             console.print(f"* {command}")
-            command_path = serve_command_path / command
+            command_path = self.serve_bin_path / command
             env_vars = ""
             if serve.env:
                 env_vars = " ".join([f"{k}={v}" for k, v in serve.env.items()])
@@ -707,8 +721,7 @@ class LocalBuilder:
 
     def run_serve_command(self, command: str) -> None:
         console.print(f"\n[bold]Running {command} command[/bold]")
-        base_path = self.get_serve_path() / "bin"
-        command_path = base_path / command
+        command_path = self.serve_bin_path / command
         sh.Command(str(command_path))(_out=write_stdout, _err=write_stderr)
 
 
@@ -808,9 +821,6 @@ class WasmerBuilder:
     ) -> None:
         return self.inner_builder.build(env, mounts, build)
 
-    def get_build_path(self) -> Path:
-        return Path("/app")
-
     def build_prepare(self, serve: Serve) -> None:
         print("Building prepare")
         prepare_dir = self.wasmer_dir_path / "prepare"
@@ -1704,7 +1714,7 @@ def main() -> None:
         app()
     except Exception as e:
         console.print(f"[bold red]{type(e).__name__}[/bold red]: {e}")
-        raise e
+        # raise e
 
 
 if __name__ == "__main__":

shipit/generator.py

@@ -109,7 +109,7 @@ def generate_shipit(path: Path, custom_commands: CustomCommands) -> str:
 
     build_steps_block = ",\n".join([f"    {s}" for s in build_steps])
     deps_array = ", ".join(serve_dep_vars)
-    commands_lines = ",\n".join([f'    "{k}": {v}' for k, v in plan.commands.items()])
+    commands_lines = ",\n".join([f'    "{k}": {v}.replace("$PORT", PORT)' for k, v in plan.commands.items()])
     env_lines = None
     if plan.env is not None:
         if len(plan.env) == 0:
@@ -119,31 +119,43 @@ def generate_shipit(path: Path, custom_commands: CustomCommands) -> str:
     mounts_block = None
     volumes_block = None
     attach_serve_names: list[str] = []
+
     if plan.mounts:
         mounts = list(filter(lambda m: m.attach_to_serve, plan.mounts))
         attach_serve_names = [m.name for m in mounts]
         mounts_block = ",\n".join([f"    {m.name}" for m in mounts])
+
     if plan.volumes:
         volumes_block = ",\n".join(
             [f"    {v.var_name or v.name}" for v in plan.volumes]
         )
 
     out: List[str] = []
+
     if dep_block:
         out.append(dep_block)
         out.append("")
+
     for m in plan.mounts:
         out.append(f"{m.name} = mount(\"{m.name}\")")
+        out.append("")
+
     if plan.volumes:
         for v in plan.volumes:
             out.append(f"{v.var_name or v.name} = volume(\"{v.name}\", {v.serve_path})")
+        out.append("")
+
     if plan.services:
         for s in plan.services:
             out.append(f"{s.name} = service(\n  name=\"{s.name}\",\n  provider=\"{s.provider}\"\n)")
+        out.append("")
+
+    out.append("PORT = getenv(\"PORT\") or\"8080\"")
 
     if plan.declarations:
         out.append(plan.declarations)
-        out.append("")
+    
+    out.append("")
     out.append("serve(")
     out.append(f'  name="{plan.serve_name}",')
     out.append(f'  provider="{plan.provider}",')

shipit/providers/hugo.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Dict, Optional
 
-from .base import DetectResult, DependencySpec, Provider, _exists, ServiceSpec, VolumeSpec, CustomCommands
+from .base import DetectResult, DependencySpec, Provider, _exists, ServiceSpec, VolumeSpec, CustomCommands, MountSpec
 from .staticfile import StaticFileProvider
 
 class HugoProvider(StaticFileProvider):
@@ -43,10 +43,14 @@ class HugoProvider(StaticFileProvider):
 
     def build_steps(self) -> list[str]:
         return [
+            'workdir(temp["build"])',
             'copy(".", ".", ignore=[".git"])',
             'run("hugo build --destination={}".format(app["build"]), group="build")',
         ]
-    
+
+    def mounts(self) -> list[MountSpec]:
+        return [MountSpec("temp", attach_to_serve=False), *super().mounts()]
+
     def services(self) -> list[ServiceSpec]:
         return []
 

shipit/providers/laravel.py

@@ -80,7 +80,7 @@ class LaravelProvider:
 
     def commands(self) -> Dict[str, str]:
         return {
-            "start": '"php -S localhost:8080 -t public"',
+            "start": 'f"php -S localhost:{PORT} -t public"',
             "after_deploy": '"php artisan migrate"',
         }
 

shipit/providers/mkdocs.py

@@ -30,6 +30,8 @@ class MkdocsProvider(StaticFileProvider):
     def detect(cls, path: Path, custom_commands: CustomCommands) -> Optional[DetectResult]:
         if _exists(path, "mkdocs.yml", "mkdocs.yaml"):
             return DetectResult(cls.name(), 85)
+        if custom_commands.build and custom_commands.build.startswith("mkdocs "):
+            return DetectResult(cls.name(), 85)
         return None
 
     def initialize(self) -> None:

shipit/providers/node_static.py

@@ -1,37 +1,206 @@
 from __future__ import annotations
 
+import json
+import yaml
 from pathlib import Path
-from typing import Dict, Optional
+from typing import Dict, Optional, Any, Set
+from enum import Enum
+from semantic_version import Version, NpmSpec
+
 
 from .base import (
     DetectResult,
     DependencySpec,
     Provider,
     _exists,
-    _has_dependency,
     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:
+class NodeStaticProvider(StaticFileProvider):
+    package_manager: PackageManager
+    package_json: Optional[Dict[str, Any]]
+    extra_dependencies: Set[str]
+
     def __init__(self, path: Path, custom_commands: CustomCommands):
-        self.path = path
-        self.custom_commands = custom_commands
+        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]:
-        pkg = path / "package.json"
-        if not pkg.exists():
+    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"]
-        if any(_has_dependency(pkg, dep) for dep in static_generators):
+        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
 
@@ -45,6 +214,8 @@ class NodeStaticProvider:
         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",
@@ -52,37 +223,82 @@ class NodeStaticProvider:
                 default_version="22",
                 use_in_build=True,
             ),
-            DependencySpec("npm", 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 = "dist" if (self.path / "dist").exists() else "public"
+        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 [
-            "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\"]))",
+            '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 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")]
+        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/providers/php.py

@@ -92,9 +92,9 @@ class PhpProvider:
 
     def base_commands(self) -> Dict[str, str]:
         if _exists(self.path, "public/index.php"):
-            return {"start": '"php -S localhost:8080 -t public"'}
+            return {"start": 'f"php -S localhost:{PORT} -t public"'}
         elif _exists(self.path, "index.php"):
-            return {"start": '"php -S localhost:8080 -t ."'}
+            return {"start": 'f"php -S localhost:{PORT} -t ."'}
 
     def mounts(self) -> list[MountSpec]:
         return [

shipit/providers/python.py

@@ -284,7 +284,7 @@ class PythonProvider:
         if not self.only_build:
             steps = ['workdir(app["build"])']
         else:
-            steps = []
+            steps = ['workdir(temp["build"])']
 
         extra_deps = ", ".join([f"{dep}" for dep in self.extra_dependencies])
         has_requirements = _exists(self.path, "requirements.txt")
@@ -317,7 +317,7 @@ class PythonProvider:
             ]
             if not self.only_build:
                 steps += [
-                    'run(f"uv pip compile pyproject.toml --python-version={python_version} --universal --extra-index-url {python_extra_index_url} --index-url=https://pypi.org/simple --emit-index-url -o cross-requirements.txt", outputs=["cross-requirements.txt"]) if cross_platform else None',
+                    'run(f"uv pip compile pyproject.toml --python-version={python_version} --universal --extra-index-url {python_extra_index_url} --index-url=https://pypi.org/simple --emit-index-url --no-deps -o cross-requirements.txt", outputs=["cross-requirements.txt"]) if cross_platform else None',
                     f'run(f"uvx pip install -r cross-requirements.txt {extra_deps} --target {{python_cross_packages_path}} --platform {{cross_platform}} --only-binary=:all: --python-version={{python_version}} --compile") if cross_platform else None',
                     'run("rm cross-requirements.txt") if cross_platform else None',
                 ]
@@ -337,7 +337,7 @@ class PythonProvider:
                 ]
             if not self.only_build:
                 steps += [
-                    'run(f"uv pip compile requirements.txt --python-version={python_version} --universal --extra-index-url {python_extra_index_url} --index-url=https://pypi.org/simple --emit-index-url -o cross-requirements.txt", inputs=["requirements.txt"], outputs=["cross-requirements.txt"]) if cross_platform else None',
+                    'run(f"uv pip compile requirements.txt --python-version={python_version} --universal --extra-index-url {python_extra_index_url} --index-url=https://pypi.org/simple --emit-index-url --no-deps -o cross-requirements.txt", inputs=["requirements.txt"], outputs=["cross-requirements.txt"]) if cross_platform else None',
                     f'run(f"uvx pip install -r cross-requirements.txt {extra_deps} --target {{python_cross_packages_path}} --platform {{cross_platform}} --only-binary=:all: --python-version={{python_version}} --compile") if cross_platform else None',
                     'run("rm cross-requirements.txt") if cross_platform else None',
                 ]
@@ -396,20 +396,20 @@ class PythonProvider:
             if self.server == PythonServer.Daphne and self.asgi_application:
                 asgi_application = format_app_import(self.asgi_application)
                 start_cmd = (
-                    f'"python -m daphne {asgi_application} --bind 0.0.0.0 --port 8000"'
+                    f'f"python -m daphne {asgi_application} --bind 0.0.0.0 --port {{PORT}}"'
                 )
             elif self.server == PythonServer.Uvicorn:
                 if self.asgi_application:
                     asgi_application = format_app_import(self.asgi_application)
-                    start_cmd = f'"python -m uvicorn {asgi_application} --host 0.0.0.0 --port 8000"'
+                    start_cmd = f'f"python -m uvicorn {asgi_application} --host 0.0.0.0 --port {{PORT}}"'
                 elif self.wsgi_application:
                     wsgi_application = format_app_import(self.wsgi_application)
-                    start_cmd = f'"python -m uvicorn {wsgi_application} --interface=wsgi --host 0.0.0.0 --port 8000"'
+                    start_cmd = f'f"python -m uvicorn {wsgi_application} --interface=wsgi --host 0.0.0.0 --port {{PORT}}"'
             # elif self.server == PythonServer.Gunicorn:
-            #     start_cmd = f'"python -m gunicorn {self.wsgi_application} --bind 0.0.0.0 --port 8000"'
+            #     start_cmd = f'"fpython -m gunicorn {self.wsgi_application} --bind 0.0.0.0 --port {{PORT}}"'
             if not start_cmd:
                 # We run the default runserver command if no server is specified
-                start_cmd = '"python manage.py runserver 0.0.0.0:8000"'
+                start_cmd = 'f"python manage.py runserver 0.0.0.0:{PORT}"'
             migrate_cmd = '"python manage.py migrate"'
             return {"start": start_cmd, "after_deploy": migrate_cmd}
 
@@ -423,21 +423,21 @@ class PythonProvider:
             python_path = file_to_python_path(main_file)
             path = f"{python_path}:app"
             if self.server == PythonServer.Uvicorn:
-                start_cmd = f'"python -m uvicorn {path} --host 0.0.0.0 --port 8000"'
+                start_cmd = f'f"python -m uvicorn {path} --host 0.0.0.0 --port {{PORT}}"'
             elif self.server == PythonServer.Hypercorn:
-                start_cmd = f'"python -m hypercorn {path} --bind 0.0.0.0:8000"'
+                start_cmd = f'f"python -m hypercorn {path} --bind 0.0.0.0:{{PORT}}"'
             else:
                 start_cmd = '"python -c \'print(\\"No start command detected, please provide a start command manually\\")\'"'
             return {"start": start_cmd}
 
         elif self.framework == PythonFramework.Streamlit:
-            start_cmd = f'"python -m streamlit run {main_file} --server.port 8000 --server.address 0.0.0.0 --server.headless true"'
+            start_cmd = f'f"python -m streamlit run {main_file} --server.port {{PORT}} --server.address 0.0.0.0 --server.headless true"'
 
         elif self.framework == PythonFramework.Flask:
             python_path = file_to_python_path(main_file)
             path = f"{python_path}:app"
-            # start_cmd = f'"python -m flask --app {path} run --debug --host 0.0.0.0 --port 8000"'
-            start_cmd = f'"python -m uvicorn {path} --interface=wsgi --host 0.0.0.0 --port 8000"'
+            # start_cmd = f'f"python -m flask --app {path} run --debug --host 0.0.0.0 --port {{PORT}}"'
+            start_cmd = f'f"python -m uvicorn {path} --interface=wsgi --host 0.0.0.0 --port {{PORT}}"'
 
         elif self.framework == PythonFramework.MCP:
             contents = (self.path / main_file).read_text()
@@ -449,7 +449,7 @@ class PythonProvider:
         elif self.framework == PythonFramework.FastHTML:
             python_path = file_to_python_path(main_file)
             path = f"{python_path}:app"
-            start_cmd = f'"python -m uvicorn {path} --host 0.0.0.0 --port 8000"'
+            start_cmd = f'f"python -m uvicorn {path} --host 0.0.0.0 --port {{PORT}}"'
 
         else:
             start_cmd = f'"python {main_file}"'
@@ -459,6 +459,7 @@ class PythonProvider:
     def mounts(self) -> list[MountSpec]:
         if self.only_build:
             return [
+                MountSpec("temp", attach_to_serve=False),
                 MountSpec("local_venv", attach_to_serve=False),
             ]
         return [
@@ -486,7 +487,7 @@ class PythonProvider:
             env_vars["STREAMLIT_SERVER_HEADLESS"] = '"true"'
         elif self.framework == PythonFramework.MCP:
             env_vars["FASTMCP_HOST"] = '"0.0.0.0"'
-            env_vars["FASTMCP_PORT"] = '"8000"'
+            env_vars["FASTMCP_PORT"] = 'PORT'
         return env_vars
     
     def services(self) -> list[ServiceSpec]:

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/providers/staticfile.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 from pathlib import Path
 from typing import Dict, Optional
+import json
+import yaml
 
 from .base import (
     DetectResult,
@@ -16,9 +18,19 @@ 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
         self.custom_commands = custom_commands
+        if (self.path / "Staticfile").exists():
+            try:
+                self.config = yaml.safe_load((self.path / "Staticfile").read_text())
+            except yaml.YAMLError as e:
+                print(f"Error loading Staticfile: {e}")
+                pass
 
     @classmethod
     def name(cls) -> str:
@@ -58,7 +70,7 @@ class StaticFileProvider:
     def build_steps(self) -> list[str]:
         return [
             'workdir(app["build"])',
-            'copy(".", ".", ignore=[".git"])'
+            'copy({}, ".", ignore=[".git"])'.format(json.dumps(self.config and self.config.get("root") or "."))
         ]
 
     def prepare_steps(self) -> Optional[list[str]]:
@@ -69,7 +81,7 @@ class StaticFileProvider:
 
     def commands(self) -> Dict[str, str]:
         return {
-            "start": '"static-web-server --root={} --log-level=info".format(app["serve"])'
+            "start": '"static-web-server --root={} --log-level=info --port={}".format(app["serve"], PORT)'
         }
 
     def mounts(self) -> list[MountSpec]:

shipit/providers/wordpress.py

@@ -70,7 +70,7 @@ class WordPressProvider(PhpProvider):
 
     def commands(self) -> Dict[str, str]:
         return {
-            "start": '"php -S localhost:8080 -t ."',
+            "start": 'f"php -S localhost:{PORT} -t ."',
             "wp": '"php {}/wp-cli.phar --allow-root --path={}".format(assets[\"serve\"], app[\"serve\"])',
             "after_deploy": '"bash {}/wordpress-install.sh".format(assets["serve"])',
         }

shipit/version.py

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

{shipit_cli-0.7.1.dist-info → shipit_cli-0.9.0.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: shipit-cli
-Version: 0.7.1
-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.9.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+shipit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+shipit/cli.py,sha256=NMZ6xSLq8MlV9yT3FLi9XZ5IBw2IMppoPna_vl9LK1Y,59170
+shipit/generator.py,sha256=W4MynSFwId4PRWWrF0R3NsANye_Zv8TwXCUXai94pW0,6553
+shipit/procfile.py,sha256=GlfdwzFUr0GWGKaaiXlLKNFInWaRNMy_wN14UEyU_5Q,2974
+shipit/version.py,sha256=0hkQAsOavRu0fhDHnq4yN300QZjC88Y_Nr7gIReJ_9Y,95
+shipit/assets/php/php.ini,sha256=f4irndAjB4GuuouEImRkNV22Q-yw1KqR-43jAMDw730,2531
+shipit/assets/wordpress/install.sh,sha256=fJkVeGAw_dj-ywmQipAWRjaz57sayD6F0OFvZKMIKug,669
+shipit/assets/wordpress/wp-config.php,sha256=IdGQoeg8E89JiqwxO2i8WnGMzmhNWgRz80X6lbU5GXc,4134
+shipit/providers/base.py,sha256=-lraLhnXtc2SfYNIUiyry7xD2NL4q0n6voNjr6qfRis,2994
+shipit/providers/gatsby.py,sha256=kzfS-z040GaJ0a9u2_6S6K-ykGSX2yPG17VpjUWBOBA,2393
+shipit/providers/hugo.py,sha256=l3IZ14LGYc3wQ7Uk0iQMDNN9Syd1G4HPzm0ePCGFyzE,1808
+shipit/providers/laravel.py,sha256=2rCuOi2kC5OYQfAG7C0NMhG7KEgzfudwUT_CvVFz4hM,3031
+shipit/providers/mkdocs.py,sha256=mDJpT3rzYAr5Vw-yt5fCpV0QgBZyksn9MrkPd4nzROU,2200
+shipit/providers/node_static.py,sha256=j5VKT_RblonIHTtpiUNai4e_izZUhbyLtPTsGeALpcY,11508
+shipit/providers/php.py,sha256=BSOqS3UhABoe_ued8aXtyn0KdqWbOCq6VV2ehtoBlmk,3547
+shipit/providers/python.py,sha256=kQpaaQi8ajHM_SFk2xI5lRIeOc6PXSKumb-Tv_5n6m0,20954
+shipit/providers/registry.py,sha256=JCuQaYTvJcWK1nS-om9TIQgGW6pT5BuNLIRzChLLFWE,731
+shipit/providers/staticfile.py,sha256=F4thEuihDW-h5DO-lotrjSdHYWzoXofQPpsAgWonvpY,2677
+shipit/providers/wordpress.py,sha256=Wjc1fgFburewlf4hQ2ZmxTQko_SHQW-8jrDukzKx0Gs,3019
+shipit_cli-0.9.0.dist-info/METADATA,sha256=ULUMj5u3OzMZA00AoJJOxA0iAsHIw5R-d8IODyR0hJ8,615
+shipit_cli-0.9.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+shipit_cli-0.9.0.dist-info/entry_points.txt,sha256=7AE1NjSrHaSDfbfsRRO50KKnHFTbB0Imsccd1WynzAQ,72
+shipit_cli-0.9.0.dist-info/RECORD,,

shipit_cli-0.7.1.dist-info/RECORD

@@ -1,23 +0,0 @@
-shipit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-shipit/cli.py,sha256=1U65pviCsaH-fZO3hGYWoyO1WqXCfOxnGwPIomwc5Fg,58363
-shipit/generator.py,sha256=GFsuqZG83gn7yxphE4GHwZjEB3sToJn24yNDE-zrTtM,6400
-shipit/procfile.py,sha256=GlfdwzFUr0GWGKaaiXlLKNFInWaRNMy_wN14UEyU_5Q,2974
-shipit/version.py,sha256=-1rPwQ4VEhKG8LAXODaAwzxwpFY9hDgohd2s_aRySc4,95
-shipit/assets/php/php.ini,sha256=f4irndAjB4GuuouEImRkNV22Q-yw1KqR-43jAMDw730,2531
-shipit/assets/wordpress/install.sh,sha256=GOIwJX3qPp7VuZXjkKVFFY6Mo9k7VFWfobS6aZYitPg,817
-shipit/assets/wordpress/wp-config.php,sha256=IdGQoeg8E89JiqwxO2i8WnGMzmhNWgRz80X6lbU5GXc,4134
-shipit/providers/base.py,sha256=-lraLhnXtc2SfYNIUiyry7xD2NL4q0n6voNjr6qfRis,2994
-shipit/providers/gatsby.py,sha256=kzfS-z040GaJ0a9u2_6S6K-ykGSX2yPG17VpjUWBOBA,2393
-shipit/providers/hugo.py,sha256=BvSYTDTVxHz6FW2mA4sqIsNayFRo5BK6Z4tWFRRimmY,1644
-shipit/providers/laravel.py,sha256=yhOnaaXZ2US8EO5ZD5pBTerSOBi9IWBBIqeQrbW7YoM,3028
-shipit/providers/mkdocs.py,sha256=pWTeIUEnSyB653s7Cw_OSllgiSGcDymRTEHgV5ChDLM,2070
-shipit/providers/node_static.py,sha256=QVUTTZbvUGtj2yT9WTbGmuM30rJzejnp76crIqSGA7o,2564
-shipit/providers/php.py,sha256=JIWl5CdVEdf9DAr9O9rR8NucucYCj_M5PbJRw_SnmYU,3541
-shipit/providers/python.py,sha256=n0748miZ5RpQyQUCmkq3_G2Nnub8SaogZoJTNNFalZc,20801
-shipit/providers/registry.py,sha256=lHUViVuPJf1OIZD8I_NTX4LP7E3Uo5-MmLfarmAA_cM,729
-shipit/providers/staticfile.py,sha256=O1D0cXa_cFZH4OXRFLjBG3e-LbjMDo7ZBC2D3CvrPo4,2218
-shipit/providers/wordpress.py,sha256=wMIcBpICqcEpbOgJCufrnM-r76AVI7_xC-NUlh9XMmE,3016
-shipit_cli-0.7.1.dist-info/METADATA,sha256=uW1Lt7b6mOl7H5k3CPpaPPWNNr-0DHY6p5dxE4Z9B6g,523
-shipit_cli-0.7.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-shipit_cli-0.7.1.dist-info/entry_points.txt,sha256=7AE1NjSrHaSDfbfsRRO50KKnHFTbB0Imsccd1WynzAQ,72
-shipit_cli-0.7.1.dist-info/RECORD,,