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

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

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

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

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

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

@@ -18,6 +18,12 @@ echo "Creating required directories..."
 mkdir -p wp-content/plugins
 mkdir -p wp-content/upgrade
 
+if [ -n "${WPCONTENT_BASE_PATH:-}" ] && [ -d "${WPCONTENT_BASE_PATH}" ]; then
+  shopt -s dotglob nullglob
+  cp -R "${WPCONTENT_BASE_PATH}"/* /app/wp-content
+  shopt -u dotglob nullglob
+fi
+
 echo "Installing WordPress core"
 
 wp core install \
@@ -28,7 +34,6 @@ wp core install \
   --admin_email="$WP_ADMIN_EMAIL" \
   --locale="$WP_LOCALE"
 
-
 if [ "${WP_UPDATE_DB:-false}" = "true" ]; then
     echo "Updating database..."
     wp core update-db
@@ -96,11 +101,13 @@ if [ -n "${WP_LOCALE:-}" ]; then
   wp site switch-language "$WP_LOCALE"
 fi
 
-cat > /app/wp-content/wp-config.php <<EOF
+if [ ! -f "/app/wp-content/wp-config.php" ]; then
+  cat > /app/wp-content/wp-config.php <<EOF
 <?php
 // If you need to set custom configuration, you can place it here.
 // This file will be included by the main wp-config.php after
 // loading environment variables.
 EOF
+fi
 
 echo "✅ WordPress Installation complete"

{shipit_cli-0.18.2 → shipit_cli-0.19.1}/src/shipit/assets/wordpress/wp-config.php

@@ -72,10 +72,6 @@ function get_env_var(string $name, string $default = '')
         return env_var_deserialize($value);
     }
 
-    if ($default === '') {
-        error_log("Warning: env var " . $name . " was not provided.");
-    }
-
     return $default;
 }
 

{shipit_cli-0.18.2 → shipit_cli-0.19.1}/src/shipit/builders/base.py

@@ -11,4 +11,5 @@ class BuildBackend(Protocol):
     ) -> None: ...
     def get_build_mount_path(self, name: str) -> Path: ...
     def get_artifact_mount_path(self, name: str) -> Path: ...
+    def get_volume_path(self, name: str) -> Path: ...
     def get_runtime_path(self) -> Optional[str]: ...

{shipit_cli-0.18.2 → shipit_cli-0.19.1}/src/shipit/builders/docker.py

@@ -21,6 +21,7 @@ from shipit.shipit_types import (
     RunStep,
     Step,
     UseStep,
+    WriteFileStep,
     WorkdirStep,
 )
 from shipit.ui import console, write_stderr, write_stdout
@@ -75,6 +76,9 @@ class DockerBuildBackend:
     def get_artifact_mount_path(self, name: str) -> Path:
         return self.docker_out_path / self.get_mount_path(name)
 
+    def get_volume_path(self, name: str) -> Path:
+        return self.src_dir / ".shipit" / "volumes" / name
+
     @property
     def is_depot(self) -> bool:
         return self.docker_client == "depot"
@@ -210,6 +214,15 @@ RUN curl https://mise.run | sh
             elif isinstance(step, PathStep):
                 docker_file_contents += f"ENV PATH={step.path}:$PATH\n"
                 env["PATH"] = f"{step.path}{os.pathsep}{env.get('PATH', '')}"
+            elif isinstance(step, WriteFileStep):
+                content_base64 = base64.b64encode(
+                    step.content.encode("utf-8")
+                ).decode("utf-8")
+                target_path = Path(step.path)
+                docker_file_contents += (
+                    f"RUN mkdir -p {target_path.parent} "
+                    f"&& echo '{content_base64}' | base64 -d > {target_path}\n"
+                )
             elif isinstance(step, UseStep):
                 for dependency in step.dependencies:
                     if dependency.name == "pie":

{shipit_cli-0.18.2 → shipit_cli-0.19.1}/src/shipit/builders/local.py

@@ -17,6 +17,7 @@ from shipit.shipit_types import (
     RunStep,
     Step,
     UseStep,
+    WriteFileStep,
     WorkdirStep,
 )
 from shipit.ui import console, write_stderr, write_stdout
@@ -44,6 +45,9 @@ class LocalBuildBackend:
     def get_artifact_mount_path(self, name: str) -> Path:
         return self.get_mount_path(name)
 
+    def get_volume_path(self, name: str) -> Path:
+        return self.src_dir / ".shipit" / "volumes" / name
+
     def execute_step(self, step: Step, env: Dict[str, str]) -> None:
         build_path = self.workdir
         if isinstance(step, UseStep):
@@ -132,6 +136,13 @@ class LocalBuildBackend:
             console.print(f"[bold]Add {step.path}[/bold] to PATH")
             fullpath = step.path
             env["PATH"] = f"{fullpath}{os.pathsep}{env['PATH']}"
+        elif isinstance(step, WriteFileStep):
+            target = Path(step.path)
+            if not target.is_absolute():
+                target = build_path / target
+            console.print(f"[bold]Write file {target}[/bold]")
+            target.parent.mkdir(parents=True, exist_ok=True)
+            target.write_text(step.content)
         else:
             raise Exception(f"Unknown step type: {type(step)}")
 

{shipit_cli-0.18.2 → shipit_cli-0.19.1}/src/shipit/cli.py

@@ -31,15 +31,18 @@ from shipit.shipit_types import (
     Step,
     UseStep,
     Volume,
+    WriteFileStep,
     WorkdirStep,
 )
 from shipit.ui import console
 from shipit.version import version as shipit_version
+from shipit.volumes import build_volumes, load_volume_mappings
 
 app = typer.Typer(invoke_without_command=True)
 
 DIR_PATH = Path(__file__).resolve().parent
 ASSETS_PATH = DIR_PATH / "assets"
+OPTIONAL_RUN_COMMANDS = {"start", "after_deploy"}
 
 
 @dataclass
@@ -195,6 +198,10 @@ class Ctx:
         step = EnvStep(env_vars)
         return self.add_step(step)
 
+    def write(self, path: str, content: str) -> Optional[str]:
+        step = WriteFileStep(path, content)
+        return self.add_step(step)
+
     def add_mount(self, mount: Mount) -> Optional[str]:
         self.mounts.append(mount)
         return f"ref:mount:{len(self.mounts) - 1}"
@@ -216,12 +223,18 @@ class Ctx:
         return f"ref:volume:{len(self.volumes) - 1}"
 
     def volume(self, name: str, serve: str) -> Optional[str]:
-        volume = Volume(name=name, serve_path=Path(serve))
+        volume = Volume(
+            name=name,
+            path=self.build_backend.get_volume_path(name),
+            serve_path=Path(serve),
+        )
         ref = self.add_volume(volume)
         return {
             "ref": ref,
             "name": name,
+            "path": str(volume.path.absolute()),
             "serve": str(volume.serve_path),
+            "serve_path": str(volume.serve_path),
         }
 
 
@@ -245,6 +258,7 @@ def evaluate_shipit(
     glb.set("volume", ctx.volume)
     glb.set("workdir", ctx.workdir)
     glb.set("copy", ctx.copy)
+    glb.set("write", ctx.write)
     glb.set("path", ctx.path)
     glb.set("env", ctx.env)
     glb.set("use", ctx.use)
@@ -359,9 +373,18 @@ def auto(
         False,
         help="Run the prepare command after building (defaults to True).",
     ),
+    run_commands: Optional[List[str]] = typer.Option(
+        None,
+        "--run",
+        help="Run one or more serve commands after building. Can be passed multiple times.",
+    ),
     start: bool = typer.Option(
         False,
-        help="Run the start command after building.",
+        help="Equivalent to `--run=start`.",
+    ),
+    after_deploy: bool = typer.Option(
+        False,
+        help="Equivalent to `--run=after_deploy`.",
     ),
     regenerate: bool = typer.Option(
         None,
@@ -479,14 +502,16 @@ def auto(
         provider=provider,
         config=config,
     )
-    if start or wasmer_deploy or wasmer_deploy_config:
+    if run_commands or start or after_deploy or wasmer_deploy or wasmer_deploy_config:
         serve(
             path,
             wasmer=wasmer,
             wasmer_bin=wasmer_bin,
             docker=docker,
             docker_client=docker_client,
+            run_commands=run_commands,
             start=start,
+            after_deploy=after_deploy,
             wasmer_token=wasmer_token,
             wasmer_registry=wasmer_registry,
             wasmer_deploy=wasmer_deploy,
@@ -619,9 +644,18 @@ def serve(
         None,
         help="Additional options to pass to the Docker client.",
     ),
+    run_commands: Optional[List[str]] = typer.Option(
+        None,
+        "--run",
+        help="Run one or more serve commands. Can be passed multiple times.",
+    ),
     start: Optional[bool] = typer.Option(
         True,
-        help="Run the start command after building.",
+        help="Equivalent to `--run=start`.",
+    ),
+    after_deploy: bool = typer.Option(
+        False,
+        help="Equivalent to `--run=after_deploy`.",
     ),
     wasmer_deploy: Optional[bool] = typer.Option(
         False,
@@ -672,6 +706,12 @@ def serve(
     else:
         runner = LocalRunner(build_backend, path)
 
+    commands_to_run = resolve_run_commands(
+        run_commands=run_commands,
+        start=bool(start),
+        after_deploy=after_deploy,
+    )
+
     if wasmer_deploy_config:
         if not isinstance(runner, WasmerRunner):
             raise RuntimeError("--wasmer-deploy-config requires the Wasmer runner")
@@ -680,8 +720,8 @@ def serve(
         if not isinstance(runner, WasmerRunner):
             raise RuntimeError("--wasmer-deploy requires the Wasmer runner")
         runner.deploy(app_owner=wasmer_app_owner, app_name=wasmer_app_name)
-    elif start:
-        runner.run_serve_command("start")
+    elif commands_to_run:
+        run_serve_commands(path, runner, commands_to_run)
 
 
 @app.command(name="plan")
@@ -1034,6 +1074,7 @@ def build(
 
     # Build and serve
     build_backend.build(serve.name, env, serve.mounts or [], build_steps)
+    build_volumes(path, serve)
     runner.build(serve)
     if serve.prepare and not skip_prepare:
         runner.prepare(env, serve.prepare)
@@ -1053,6 +1094,27 @@ def get_shipit_path(path: Path, shipit_path: Optional[Path] = None) -> Path:
     return shipit_path
 
 
+def resolve_run_commands(
+    run_commands: Optional[List[str]],
+    start: bool,
+    after_deploy: bool,
+) -> List[str]:
+    commands = list(run_commands or [])
+    if after_deploy and "after_deploy" not in commands:
+        commands.append("after_deploy")
+    if start and "start" not in commands:
+        commands.append("start")
+    return commands
+
+
+def run_serve_commands(path: Path, runner: Runner, commands: List[str]) -> None:
+    volume_mappings = load_volume_mappings(path)
+    for command in commands:
+        if command in OPTIONAL_RUN_COMMANDS and not runner.has_serve_command(command):
+            continue
+        runner.run_serve_command(command, volume_mappings=volume_mappings)
+
+
 def main() -> None:
     args = sys.argv[1:]
     # If no subcommand or first token looks like option/path → default to "build"

{shipit_cli-0.18.2 → shipit_cli-0.19.1}/src/shipit/providers/mkdocs.py

@@ -25,7 +25,7 @@ class MkdocsConfig(PythonConfig, StaticFileConfig):
 
 class MkdocsProvider(StaticFileProvider):
     def __init__(self, path: Path, config: MkdocsConfig):
-        self.path = path
+        super().__init__(path, config)
         self.python_provider = PythonProvider(path, config, only_build=True)
 
     @classmethod

{shipit_cli-0.18.2 → shipit_cli-0.19.1}/src/shipit/providers/node_static.py

@@ -432,7 +432,7 @@ class NodeStaticProvider(StaticFileProvider):
                 'run("cp -R {}/* {}/".format(config.static_dir, static_app.path))'
                 if not self.only_build
                 else None,
-            ],
+            ] + self.build_steps_redirects(),
         )
 
     def prepare_steps(self) -> Optional[list[str]]:

shipit_cli-0.19.1/src/shipit/providers/staticfile.py

@@ -0,0 +1,328 @@
+import json
+import re
+import shlex
+from dataclasses import dataclass
+from functools import cached_property
+from pathlib import Path
+from typing import Dict, Optional
+
+from tomlkit import aot, document, table
+import yaml
+from pydantic_settings import SettingsConfigDict
+
+from .base import (
+    DetectResult,
+    DependencySpec,
+    Provider,
+    _exists,
+    MountSpec,
+    ServiceSpec,
+    VolumeSpec,
+    Config,
+)
+
+
+class StaticFileConfig(Config):
+    model_config = SettingsConfigDict(extra="ignore", env_prefix="SHIPIT_")
+
+    convert_redirects: bool = True
+    sws_version: Optional[str] = "2.38.0"
+    static_dir: Optional[str] = None
+
+
+@dataclass(frozen=True)
+class RedirectRule:
+    source: str
+    destination: str
+    kind: int
+
+
+class StaticFileProvider:
+    REDIRECTS_CONFIG_FILE = "sws.toml"
+    REDIRECTS_CONFIG_MOUNT = "static_config"
+    REDIRECTS_SOURCE = "_redirects"
+    REDIRECT_STATUS_CODES = {301, 302}
+    _PARAM_PATTERN = re.compile(r":([A-Za-z][A-Za-z0-9_]*)")
+    _SOURCE_TOKEN_PATTERN = re.compile(r":([A-Za-z][A-Za-z0-9_]*)|\*")
+
+    config: Optional[dict] = None
+    path: Path
+
+    def __init__(self, path: Path, config: StaticFileConfig):
+        self.path = path
+        self.config = config
+
+    @classmethod
+    def load_config(
+        cls, path: Path, base_config: Config
+    ) -> StaticFileConfig:
+        if (path / "Staticfile").exists():
+            config = None
+            try:
+                config = yaml.safe_load((path / "Staticfile").read_text())
+            except yaml.YAMLError as e:
+                print(f"Error loading Staticfile: {e}")
+                pass
+
+            if config:
+                return StaticFileConfig(
+                    **base_config.model_dump(),
+                    static_dir=config.get("root"),
+                )
+        if _exists(path, "public/index.html") or _exists(path, "public/index.htm"):
+            return StaticFileConfig(static_dir="public", **base_config.model_dump())
+
+        return StaticFileConfig(**base_config.model_dump())
+
+    @classmethod
+    def name(cls) -> str:
+        return "staticfile"
+
+    @classmethod
+    def detect(
+        cls, path: Path, config: Config
+    ) -> Optional[DetectResult]:
+        is_python_php_js_project = _exists(
+            path, "package.json", "pyproject.toml", "composer.json"
+        )
+        if _exists(path, "Staticfile"):
+            return DetectResult(cls.name(), 50)
+        if not is_python_php_js_project:
+            if _exists(
+                path, "index.html", "index.htm", "public/index.htm", "public/index.html"
+            ):
+                return DetectResult(cls.name(), 10)
+            return DetectResult(cls.name(), 10)
+        if config.commands.start and config.commands.start.startswith(
+            "static-web-server "
+        ):
+            return DetectResult(cls.name(), 70)
+        return None
+
+    def dependencies(self) -> list[DependencySpec]:
+        return [
+            DependencySpec(
+                "static-web-server",
+                var_name="config.sws_version",
+                use_in_serve=True,
+            )
+        ]
+
+    def build_steps_redirects(self) -> list[str]:
+        redirects_config = self.redirects_config
+        if not redirects_config:
+            return []
+        return [
+            'write("{}/%s".format(static_config.path), %s)'
+            % (
+                self.REDIRECTS_CONFIG_FILE,
+                json.dumps(redirects_config),
+            )
+        ]
+
+    def build_steps(self) -> list[str]:
+        return [
+            'workdir(static_app.path)',
+            'copy({}, ".", ignore=[".git"])'.format(
+                json.dumps(self.config.static_dir or ".")
+            ),
+        ] + self.build_steps_redirects()
+
+    def prepare_steps(self) -> Optional[list[str]]:
+        return None
+
+    def declarations(self) -> Optional[str]:
+        return None
+
+    def commands(self) -> Dict[str, str]:
+        if self.redirects_config:
+            return {
+                "start": '"static-web-server --root={} --log-level=info --config-file={}/%s --port={}".format(static_app.serve_path, static_config.serve_path, PORT)'
+                % self.REDIRECTS_CONFIG_FILE
+            }
+        return {
+            "start": '"static-web-server --root={} --log-level=info --port={}".format(static_app.serve_path, PORT)'
+        }
+
+    def mounts(self) -> list[MountSpec]:
+        mounts = [MountSpec("static_app")]
+        if self.redirects_config:
+            mounts.append(MountSpec(self.REDIRECTS_CONFIG_MOUNT))
+        return mounts
+
+    def volumes(self) -> list[VolumeSpec]:
+        return []
+
+    def env(self) -> Optional[Dict[str, str]]:
+        return None
+
+    def services(self) -> list[ServiceSpec]:
+        return []
+
+    @cached_property
+    def redirects_config(self) -> Optional[str]:
+        if not self.config.convert_redirects:
+            return None
+
+        redirects_path = self._resolve_redirects_path()
+        if not redirects_path.is_file():
+            return None
+
+        rules = self._load_redirect_rules(redirects_path)
+        if not rules:
+            return None
+
+        doc = document()
+        advanced = table()
+        redirects = aot()
+        for rule in rules:
+            entry = table()
+            entry.add("source", rule.source)
+            entry.add("destination", rule.destination)
+            entry.add("kind", rule.kind)
+            redirects.append(entry)
+
+        advanced.add("redirects", redirects)
+        doc.add("advanced", advanced)
+        return doc.as_string()
+
+    def _resolve_redirects_path(self) -> Path:
+        if self.config.static_dir:
+            static_dir_redirects = (
+                self.path / self.config.static_dir / self.REDIRECTS_SOURCE
+            )
+            if static_dir_redirects.is_file():
+                return static_dir_redirects
+        return self.path / self.REDIRECTS_SOURCE
+
+    @classmethod
+    def _load_redirect_rules(cls, redirects_path: Path) -> list[RedirectRule]:
+        rules: list[RedirectRule] = []
+        for line_number, raw_line in enumerate(
+            redirects_path.read_text().splitlines(), start=1
+        ):
+            line = raw_line.strip()
+            if not line or line.startswith("#"):
+                continue
+
+            try:
+                parts = shlex.split(line)
+            except ValueError as exc:
+                raise ValueError(
+                    f"{redirects_path}:{line_number}: invalid _redirects rule"
+                ) from exc
+
+            if len(parts) < 2:
+                raise ValueError(
+                    f"{redirects_path}:{line_number}: expected source and "
+                    "destination"
+                )
+
+            source, destination, *rest = parts
+            kind = 301
+            if rest and rest[0].isdigit():
+                kind = int(rest[0])
+                rest = rest[1:]
+
+            if kind not in cls.REDIRECT_STATUS_CODES:
+                raise ValueError(
+                    f"{redirects_path}:{line_number}: redirect status {kind} "
+                    "is not supported by static-web-server"
+                )
+
+            if rest:
+                raise ValueError(
+                    f"{redirects_path}:{line_number}: conditions and forced "
+                    "redirects are not supported"
+                )
+
+            sws_source, replacements = cls._translate_source(
+                redirects_path, line_number, source
+            )
+            sws_destination = cls._translate_destination(
+                redirects_path, line_number, destination, replacements
+            )
+            rules.append(
+                RedirectRule(
+                    source=sws_source,
+                    destination=sws_destination,
+                    kind=kind,
+                )
+            )
+
+        return rules
+
+    @classmethod
+    def _translate_source(
+        cls, redirects_path: Path, line_number: int, source: str
+    ) -> tuple[str, dict[str, int]]:
+        if "://" in source:
+            raise ValueError(
+                f"{redirects_path}:{line_number}: redirect sources must be "
+                "local paths"
+            )
+        if "?" in source:
+            raise ValueError(
+                f"{redirects_path}:{line_number}: query matching is not "
+                "supported"
+            )
+        if not source.startswith("/"):
+            raise ValueError(
+                f"{redirects_path}:{line_number}: redirect sources must start "
+                "with '/'"
+            )
+
+        translated_parts: list[str] = []
+        replacements: dict[str, int] = {}
+        last_index = 0
+        next_index = 1
+
+        for match in cls._SOURCE_TOKEN_PATTERN.finditer(source):
+            translated_parts.append(source[last_index : match.start()])
+            param_name = match.group(1)
+            if param_name is not None:
+                if param_name in replacements:
+                    raise ValueError(
+                        f"{redirects_path}:{line_number}: duplicate source "
+                        f"parameter :{param_name}"
+                    )
+                replacements[param_name] = next_index
+                translated_parts.append("{*}")
+            else:
+                if "splat" in replacements:
+                    raise ValueError(
+                        f"{redirects_path}:{line_number}: only one splat "
+                        "segment is supported"
+                    )
+                replacements["splat"] = next_index
+                translated_parts.append("{**}")
+            next_index += 1
+            last_index = match.end()
+
+        translated_parts.append(source[last_index:])
+        return "".join(translated_parts), replacements
+
+    @classmethod
+    def _translate_destination(
+        cls,
+        redirects_path: Path,
+        line_number: int,
+        destination: str,
+        replacements: dict[str, int],
+    ) -> str:
+        if "*" in destination:
+            raise ValueError(
+                f"{redirects_path}:{line_number}: destination splats must use "
+                ":splat"
+            )
+
+        def replace_param(match: re.Match[str]) -> str:
+            param_name = match.group(1)
+            if param_name not in replacements:
+                raise ValueError(
+                    f"{redirects_path}:{line_number}: destination references "
+                    f"unknown parameter :{param_name}"
+                )
+            return f"${replacements[param_name]}"
+
+        return cls._PARAM_PATTERN.sub(replace_param, destination)