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

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

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: shipit-cli
-Version: 0.7.0
+Version: 0.8.0
 Summary: Add your description here
 Project-URL: homepage, https://wasmer.io
 Project-URL: repository, https://github.com/wasmerio/shipit
 Project-URL: Changelog, https://github.com/wasmerio/shipit/changelog
 Requires-Python: >=3.10
+Requires-Dist: dotenv>=0.9.9
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: requests>=2.32.5
 Requires-Dist: rich>=14.1.0

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

@@ -1,10 +1,11 @@
 [project]
 name = "shipit-cli"
-version = "0.7.0"
+version = "0.8.0"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
+    "dotenv>=0.9.9",
     "pyyaml>=6.0.2",
     "requests>=2.32.5",
     "rich>=14.1.0",
@@ -34,5 +35,12 @@ only-include = ["src/shipit", "tests"]
 
 [tool.uv]
 dev-dependencies = [
+    "aiohttp>=3.12.15",
     "pytest>=8.2",
+    "pytest-asyncio>=1.2.0",
+    "pytest-rerunfailures>=16.0.1",
+    "pytest-xdist>=3.8.0",
 ]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

{shipit_cli-0.7.0 → shipit_cli-0.8.0}/src/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-0.7.0 → shipit_cli-0.8.0}/src/shipit/cli.py

@@ -36,6 +36,7 @@ from shipit.version import version as shipit_version
 from shipit.generator import generate_shipit
 from shipit.providers.base import CustomCommands
 from shipit.procfile import Procfile
+from dotenv import dotenv_values
 
 
 console = Console()
@@ -147,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):
@@ -178,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 = ""
@@ -339,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]
@@ -357,8 +375,8 @@ RUN chmod {oct(mode)[2:]} {path.absolute()}
         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 \\
         sudo curl ca-certificates \\
     && rm -rf /var/lib/apt/lists/*
@@ -406,7 +424,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"
                         )
@@ -445,12 +463,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
 
@@ -460,13 +472,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,
             )
 
@@ -479,6 +490,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
@@ -502,6 +514,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:
@@ -627,12 +641,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] = []
@@ -675,14 +683,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()])
@@ -706,8 +713,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)
 
 
@@ -807,9 +813,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"
@@ -877,10 +880,10 @@ class WasmerBuilder:
         )
 
     def build_serve(self, serve: Serve) -> None:
-        from tomlkit import comment, document, nl, table, aot, string
+        from tomlkit import comment, document, nl, table, aot, string, array
 
         doc = document()
-        doc.add(comment(f"File generated by Shipit {shipit_version}"))
+        doc.add(comment(f"Wasmer manifest generated with Shipit v{shipit_version}"))
         package = table()
         doc.add("package", package)
         package.add("entrypoint", "start")
@@ -953,14 +956,14 @@ class WasmerBuilder:
                 wasi_args = table()
                 if serve.cwd:
                     wasi_args.add("cwd", serve.cwd)
-                wasi_args.add("main-args", parts[1:])
+                wasi_args.add("main-args", array(parts[1:]).multiline(True))
                 env = program_binary.get("env") or {}
                 if serve.env:
                     env.update(serve.env)
                 if env:
+                    arr = array([f"{k}={v}" for k, v in env.items()]).multiline(True)
                     wasi_args.add(
-                        "env",
-                        [f"{k}={v}" for k, v in env.items()],
+                        "env", arr
                     )
                 title = string("annotations.wasi", literal=False)
                 command.add(title, wasi_args)
@@ -1038,7 +1041,7 @@ class WasmerBuilder:
             )
             yaml_config["jobs"] = jobs
 
-        app_yaml = yaml.dump(yaml_config)
+        app_yaml = yaml.dump(yaml_config,)
 
         console.print(f"\n[bold]Created app.yaml manifest ✅[/bold]")
         app_yaml_panel = Panel(
@@ -1385,6 +1388,10 @@ def auto(
         None,
         help="The start command to use (overwrites the default)",
     ),
+    env_name: Optional[str] = typer.Option(
+        None,
+        help="The environment to use (defaults to `.env`, it will use .env.<env_name> if provided)",
+    ),
 ):
     if not path.exists():
         raise Exception(f"The path {path} does not exist")
@@ -1408,6 +1415,7 @@ def auto(
         wasmer_token=wasmer_token,
         wasmer_bin=wasmer_bin,
         skip_prepare=skip_prepare,
+        env_name=env_name,
     )
     if start or wasmer_deploy:
         serve(
@@ -1612,6 +1620,10 @@ def build(
         None,
         help="Use a specific Docker client (such as depot, podman, etc.)",
     ),
+    env_name: Optional[str] = typer.Option(
+        None,
+        help="The environment to use (defaults to `.env`, it will use .env.<env_name> if provided)",
+    ),
 ) -> None:
     if not path.exists():
         raise Exception(f"The path {path} does not exist")
@@ -1664,6 +1676,14 @@ def build(
         "CLICOLOR": os.environ.get("CLICOLOR", "0"),
     }
     serve = next(iter(ctx.serves.values()))
+    serve.env = serve.env or {}
+    if (path / ".env").exists():
+        env_vars = dotenv_values(path / ".env")
+        serve.env.update(env_vars)
+
+    if (path / f".env.{env_name}").exists():
+        env_vars = dotenv_values(path / f".env.{env_name}")
+        serve.env.update(env_vars)
 
     # Build and serve
     builder.build(env, serve.mounts, serve.build)
@@ -1686,8 +1706,11 @@ 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__":
     main()
+
+def flatten(xss):
+    return [x for xs in xss for x in xs]

{shipit_cli-0.7.0 → shipit_cli-0.8.0}/src/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_cli-0.7.0 → shipit_cli-0.8.0}/src/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_cli-0.7.0 → shipit_cli-0.8.0}/src/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_cli-0.7.0 → shipit_cli-0.8.0}/src/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_cli-0.7.0 → shipit_cli-0.8.0}/src/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_cli-0.7.0 → shipit_cli-0.8.0}/src/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_cli-0.7.0 → shipit_cli-0.8.0}/src/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,17 @@ from .base import (
 
 
 class StaticFileProvider:
+    config: Optional[dict] = None
+
     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 +68,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 +79,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_cli-0.7.0 → shipit_cli-0.8.0}/src/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_cli-0.8.0/src/shipit/version.py

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

shipit_cli-0.8.0/tests/test_e2e.py

@@ -0,0 +1,359 @@
+import os
+import random
+import socket
+import signal
+import asyncio
+import subprocess
+import re
+from pathlib import Path
+from typing import List, NamedTuple
+from dataclasses import dataclass
+
+import pytest
+import shutil
+import contextlib
+import aiohttp
+from enum import Enum
+
+
+class BuildMode(Enum):
+    Wasmer = "wasmer"
+    WasmerAndDocker = "docker"
+    Local = "local"
+
+
+@dataclass(frozen=True)
+class HTTPRequest:
+    path: str
+    body_match: str
+    method: str = "GET"
+
+
+class E2ECase(NamedTuple):
+    path: str
+    serve_pattern: str
+    http: List[HTTPRequest]
+    use_random_port: bool = True
+
+    def __str__(self):
+        return self.path
+
+    def __repr__(self):
+        return self.path
+
+
+@pytest.mark.e2e
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "case",
+    [
+        # Simple PHP site that calls phpinfo()
+        E2ECase(
+            path="examples/php-nobuild",
+            serve_pattern=(
+                r"PHP 8\.3\.[0-9]+ Development Server \(http://localhost:[\d]+\) started"
+            ),
+            http=[HTTPRequest(path="/", body_match=r"PHP Version 8\.3\.[0-9]+")],
+        ),
+        # Simple PHP site that calls phpinfo() with no port
+        E2ECase(
+            path="examples/php-nobuild",
+            serve_pattern=(
+                r"PHP 8\.3\.[0-9]+ Development Server \(http://localhost:[\d]+\) started"
+            ),
+            http=[HTTPRequest(path="/", body_match=r"PHP Version 8\.3\.[0-9]+")],
+            use_random_port=False,
+        ),
+        # PHP API example with JSON at / and greeting endpoint
+        E2ECase(
+            path="examples/php-api",
+            serve_pattern=(
+                r"PHP 8\.3\.[0-9]+ Development Server \(http://localhost:[\d]+\) started"
+            ),
+            http=[
+                HTTPRequest(path="/", body_match=r"\"version\"\s*:\s*\"8\.3\.[0-9]+\""),
+                HTTPRequest(path="/api/greet/Alice", body_match=r"Hello, Alice!"),
+            ],
+        ),
+        # WordPress skeleton that echoes a simple string
+        E2ECase(
+            path="examples/php-wordpress",
+            serve_pattern=(
+                r"PHP 8\.3\.[0-9]+ Development Server \(http://localhost:[\d]+\) started"
+            ),
+            http=[HTTPRequest(path="/", body_match=r"WordPress")],
+        ),
+        # Static site copied as-is (no build step beyond copy)
+        E2ECase(
+            path="examples/static-nobuild",
+            # static-web-server banner varies; rely on HTTP check with generous pattern
+            serve_pattern=r"server is listening on",
+            http=[HTTPRequest(path="/", body_match=r"Test")],
+        ),
+        # Staticfile provider serving content under site/
+        E2ECase(
+            path="examples/staticfile",
+            serve_pattern=r"server is listening on",
+            http=[HTTPRequest(path="/", body_match=r"Hello from static site!")],
+        ),
+        # Hugo static site (built via Hugo, served with static-web-server)
+        E2ECase(
+            path="examples/hugo",
+            serve_pattern=r"server is listening on",
+            http=[HTTPRequest(path="/", body_match=r"My New Hugo Site")],
+        ),
+        # MkDocs site (built with mkdocs, served with static-web-server)
+        E2ECase(
+            path="examples/mkdocs",
+            serve_pattern=r"server is listening on",
+            http=[HTTPRequest(path="/", body_match=r"Welcome to MkDocs")],
+        ),
+        # MkDocs with plugins
+        E2ECase(
+            path="examples/mkdocs-with-plugins",
+            serve_pattern=r"server is listening on",
+            http=[HTTPRequest(path="/", body_match=r"Welcome to MkDocs with Plugins")],
+        ),
+        # Python FastAPI app on Uvicorn
+        E2ECase(
+            path="examples/python-fastapi",
+            serve_pattern=r"Uvicorn running on .*",
+            http=[HTTPRequest(path="/", body_match=r"Hello World from fastapi!")],
+        ),
+        # Python Flask app served via Uvicorn WSGI
+        E2ECase(
+            path="examples/python-flask",
+            serve_pattern=r"Uvicorn running on .*",
+            http=[HTTPRequest(path="/", body_match=r"Welcome to Flask")],
+        ),
+        # Python Django via Uvicorn WSGI (check admin login)
+        E2ECase(
+            path="examples/python-django",
+            serve_pattern=r"Uvicorn running on .*",
+            http=[HTTPRequest(path="/", body_match=r"Django")],
+        ),
+        # Python ffmpeg demo (FastAPI), homepage is static HTML form
+        E2ECase(
+            path="examples/python-ffmpeg",
+            serve_pattern=r"Uvicorn running on .*",
+            http=[HTTPRequest(path="/", body_match=r"Take screenshot at 1s")],
+        ),
+        # Python Pillow demo (FastAPI), homepage has form title
+        E2ECase(
+            path="examples/python-pillow",
+            serve_pattern=r"Uvicorn running on .*",
+            http=[HTTPRequest(path="/", body_match=r"Image Crop\s*&\s*Rotate")],
+        ),
+        # Python Pandoc demo: app may require pandoc binary; only assert serve started
+        E2ECase(
+            path="examples/python-pandoc",
+            serve_pattern=r"Uvicorn running on .*",
+            http=[],
+        ),
+        # Python Procfile demo using python -m http.server
+        E2ECase(
+            path="examples/python-procfile",
+            serve_pattern=r"Serving HTTP on .*",
+            http=[HTTPRequest(path="/", body_match=r"Test")],
+        ),
+        # Python Streamlit app
+        E2ECase(
+            path="examples/python-streamlit",
+            serve_pattern=r".*You can now view your Streamlit app in your browser.*",
+            http=[HTTPRequest(path="/", body_match=r"Streamlit")],
+        ),
+    ],
+    ids=lambda c: str(c),
+)
+@pytest.mark.flaky(reruns=5, reruns_delay=2)
+@pytest.mark.parametrize(
+    "build_mode",
+    [
+        BuildMode.Local,
+        BuildMode.Wasmer,
+        BuildMode.WasmerAndDocker,
+    ]
+)
+async def test_end_to_end(case: E2ECase, build_mode: BuildMode):
+    # Skip if `uv` is not available in PATH
+    if not shutil.which("uv"):
+        pytest.skip("`uv` is not available in PATH")
+
+    repo_root = Path(__file__).resolve().parents[1]
+
+    cmd = [
+        "uv",
+        "run",
+        "shipit-cli",
+        case.path,
+        "--skip-prepare",
+        "--start",
+        # "--wasmer",
+        # "--docker",
+        "--regenerate",
+    ]
+    if build_mode == BuildMode.Wasmer:
+        cmd.append("--wasmer")
+    elif build_mode == BuildMode.WasmerAndDocker:
+        cmd.append("--wasmer")
+        cmd.append("--docker")
+    elif build_mode == BuildMode.Local:
+        # The default
+        pass
+
+    build_phrase = "Build complete ✅"
+    serve_re = re.compile(case.serve_pattern)
+
+    # Start process in a new session/process group to simplify termination.
+    start_new_session = os.name != "nt"
+    creationflags = (
+        subprocess.CREATE_NEW_PROCESS_GROUP if os.name == "nt" else 0
+    )
+
+    env = os.environ.copy()
+    if case.use_random_port:
+        port = get_free_port()
+        env["PORT"] = str(port)
+    else:
+        port = 8080 # This is the default port if not specified
+
+    proc = await asyncio.create_subprocess_exec(
+        *cmd,
+        cwd=str(repo_root),
+        env=env,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+        start_new_session=start_new_session,
+        creationflags=creationflags,
+    )
+
+    output_lines: List[str] = []
+    found_build = asyncio.Event()
+    found_serve = asyncio.Event()
+
+    async def reader(label: str, stream: asyncio.StreamReader) -> None:
+        async for line in stream:
+            line = line.decode("utf-8", errors="replace")
+            print(f"[{label}] {line}", end='')
+            output_lines.append(f"[{label}] {line}")
+            if (not found_build.is_set()) and (build_phrase in line):
+                found_build.set()
+            if (not found_serve.is_set()) and serve_re.search(line):
+                found_serve.set()
+
+    assert proc.stdout is not None and proc.stderr is not None
+    reader_out_task = asyncio.create_task(reader("stdout", proc.stdout))
+    reader_err_task = asyncio.create_task(reader("stderr", proc.stderr))
+
+    try:
+        # Wait until both events are seen, the process exits, or timeout elapses.
+        loop = asyncio.get_running_loop()
+        end = loop.time() + 180
+        while loop.time() < end:
+            if found_build.is_set() and found_serve.is_set():
+                break
+            if proc.returncode is not None:
+                # Process ended early; stop waiting
+                break
+            await asyncio.sleep(0.05)
+
+        # If we saw the serve banner, exercise the HTTP endpoint before shutting
+        # down to ensure it actually serves content.
+        if found_serve.is_set():
+            for req in case.http:
+                ok = await _wait_for_http_contains(
+                    host="localhost",
+                    port=port,
+                    method=req.method,
+                    path=req.path,
+                    pattern=req.body_match,
+                    timeout=20.0,
+                )
+                if not ok:
+                    full_output = "".join(output_lines)
+                    pytest.fail(
+                        "Server did not return expected HTTP content.\n\n"
+                        f"Expected body regex: '{req.body_match}' at path '{req.path}'\n\n"
+                        f"--- Captured output start ---\n{full_output}\n"
+                        "--- Captured output end ---"
+                    )
+    finally:
+        # Try graceful shutdown first with Ctrl-C (SIGINT), then kill if needed
+        try:
+            if os.name != "nt":
+                os.killpg(os.getpgid(proc.pid), signal.SIGINT)
+            else:
+                # For Windows with CREATE_NEW_PROCESS_GROUP
+                proc.send_signal(signal.CTRL_BREAK_EVENT)
+        except Exception:
+            pass
+
+        # Wait briefly for graceful exit, then force kill if still running
+        try:
+            await asyncio.wait_for(proc.wait(), timeout=2)
+        except asyncio.TimeoutError:
+            if os.name != "nt":
+                os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
+            else:
+                proc.kill()
+
+        # Ensure reader tasks are finished
+        for t in (reader_out_task, reader_err_task):
+            if not t.done():
+                t.cancel()
+        for t in (reader_out_task, reader_err_task):
+            with contextlib.suppress(asyncio.CancelledError):
+                await t
+
+    full_output = "".join(output_lines)
+
+    if not (found_build.is_set() and found_serve.is_set()):
+        code = proc.returncode
+        pytest.fail(
+            "End-to-end run did not reach expected state.\n"
+            f"returncode={code}\n"
+            f"Saw build={found_build.is_set()} serve={found_serve.is_set()}\n\n"
+            f"--- Captured output start ---\n{full_output}\n--- Captured output end ---"
+        )
+
+    assert build_phrase in full_output
+    assert serve_re.search(full_output), "Serve banner regex not found in output"
+
+
+async def _wait_for_http_contains(
+    host: str,
+    port: int,
+    method: str = "GET",
+    path: str = "/",
+    pattern: str = "",
+    timeout: float = 15.0,
+) -> bool:
+    url = f"http://{host}:{port}{path}"
+    loop = asyncio.get_running_loop()
+    end = loop.time() + timeout
+    async with aiohttp.ClientSession(
+        timeout=aiohttp.ClientTimeout(total=5.0)
+    ) as session:
+        while loop.time() < end:
+            try:
+                async with session.request(method, url) as resp:
+                    text = await resp.text()
+                    if re.search(pattern, text):
+                        return True
+            except Exception:
+                # Not ready yet; retry shortly.
+                pass
+            await asyncio.sleep(0.2)
+    return False
+
+
+def get_free_port(min_port=1024, max_port=65535):
+    while True:
+        port = random.randint(min_port, max_port)
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            try:
+                s.bind(("", port))  # Bind to the port on all interfaces
+                return port
+            except OSError:
+                # Port is already in use, try another one
+                continue

{shipit_cli-0.7.0 → shipit_cli-0.8.0}/tests/test_generate_shipit_examples.py

@@ -5,6 +5,8 @@ from pathlib import Path
 import pytest
 
 from shipit.generator import generate_shipit
+from shipit.procfile import Procfile
+from shipit.providers.base import CustomCommands
 
 
 def _example_dirs_with_shipit() -> list[Path]:
@@ -25,7 +27,12 @@ def test_generate_shipit_matches_example(example_dir: Path) -> None:
     This validates provider detection and the Shipit generator formatting for
     each example that includes a `Shipit` file.
     """
-    generated = generate_shipit(example_dir)
+    custom_commands = CustomCommands()
+    if (example_dir / "Procfile").exists():
+        procfile = Procfile.loads((example_dir / "Procfile").read_text())
+        custom_commands.start = procfile.get_start_command()
+
+    generated = generate_shipit(example_dir, custom_commands=custom_commands)
     expected = (example_dir / "Shipit").read_text()
     # Use raw assert to let pytest show a unified diff on mismatch
     assert generated == expected

shipit_cli-0.7.0/src/shipit/env.py

@@ -1,30 +0,0 @@
-import shlex
-import re
-
-def parse(content):
-    """
-    Parse the content of a .env file (a line-delimited KEY=value format) into a
-    dictionary mapping keys to values.
-    """
-    values = {}
-    for line in content.splitlines():
-        lexer = shlex.shlex(line, posix=True)
-        tokens = list(lexer)
-
-        # parses the assignment statement
-        if len(tokens) < 3:
-            continue
-
-        name, op = tokens[:2]
-        value = ''.join(tokens[2:])
-
-        if op != '=':
-            continue
-        if not re.match(r'[A-Za-z_][A-Za-z_0-9]*', name):
-            continue
-
-        value = value.replace(r'\n', '\n')
-        value = value.replace(r'\t', '\t')
-        values[name] = value
-
-    return values

shipit_cli-0.7.0/src/shipit/version.py

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

shipit_cli-0.7.0/tests/test_examples_build.py

@@ -1,45 +0,0 @@
-from pathlib import Path
-from typing import List
-
-import pytest
-from typer.testing import CliRunner
-
-import shutil
-
-from shipit.cli import app, LocalBuilder
-
-
-def list_example_dirs() -> List[Path]:
-    root = Path(__file__).resolve().parents[1]
-    examples_dir = root / "examples"
-    result: List[Path] = []
-    if not examples_dir.exists():
-        return result
-    for path in sorted(examples_dir.iterdir()):
-        if path.is_dir() and (path / "Shipit").exists():
-            result.append(path)
-    return result
-
-
-@pytest.mark.parametrize("example_dir", list_example_dirs(), ids=lambda p: p.name)
-def test_shipit_build_examples_noop_commands(monkeypatch: pytest.MonkeyPatch, example_dir: Path) -> None:
-    # Make all external commands no-ops to avoid network and toolchain deps.
-    # 1) Pretend every required program exists by resolving to a benign executable.
-    true_exe = shutil.which("true") or "/usr/bin/true"
-    monkeypatch.setattr(shutil, "which", lambda *_args, **_kwargs: true_exe)
-    # 2) Neutralize any builder-level command invocations (e.g., wasmer during prepare).
-    monkeypatch.setattr(LocalBuilder, "run_command", lambda self, command, extra_args=None: None, raising=True)
-
-    runner = CliRunner()
-    # Use --wasmer to ensure examples that rely on cross-platform env build.
-    result = runner.invoke(app, ["build", "--wasmer", str(example_dir)])
-
-    # Basic sanity: command runs successfully
-    assert result.exit_code == 0, result.output
-
-    # Stable output lines from Shipit during a successful build
-    out = result.output
-    # Stable, provider-agnostic output
-    assert "Shipit" in out
-    assert "Building package" in out
-    assert "Build complete" in out