shipit-cli 0.21.0__tar.gz → 0.21.2__tar.gz

{shipit_cli-0.21.0 → shipit_cli-0.21.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shipit-cli
-Version: 0.21.0
+Version: 0.21.2
 Summary: Shipit CLI is the best way to build, serve and deploy your projects anywhere.
 Project-URL: homepage, https://wasmer.io
 Project-URL: repository, https://github.com/wasmerio/shipit

{shipit_cli-0.21.0 → shipit_cli-0.21.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "shipit-cli"
-version = "0.21.0"
+version = "0.21.2"
 description = "Shipit CLI is the best way to build, serve and deploy your projects anywhere."
 readme = "README.md"
 requires-python = ">=3.10"

{shipit_cli-0.21.0 → shipit_cli-0.21.2}/src/shipit/builders/docker.py

@@ -45,12 +45,17 @@ class DockerBuildBackend:
     }
 
     def __init__(
-        self, src_dir: Path, assets_path: Path, docker_client: Optional[str] = None,
-        docker_opts: Optional[str] = None
+        self,
+        src_dir: Path,
+        assets_path: Path,
+        docker_client: Optional[str] = None,
+        docker_opts: Optional[str] = None,
+        shipit_dir: Optional[Path] = None,
     ) -> None:
         self.src_dir = src_dir
         self.assets_path = assets_path
-        self.docker_path = self.src_dir / ".shipit" / "docker"
+        self.shipit_dir = shipit_dir or self.src_dir / ".shipit"
+        self.docker_path = self.shipit_dir / "docker"
         self.docker_path.mkdir(parents=True, exist_ok=True)
         self.docker_out_path = self.docker_path / "out"
         self.docker_file_path = self.docker_path / "Dockerfile"
@@ -77,7 +82,7 @@ class DockerBuildBackend:
         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
+        return self.shipit_dir / "volumes" / name
 
     @property
     def is_depot(self) -> bool:

{shipit_cli-0.21.0 → shipit_cli-0.21.2}/src/shipit/builders/local.py

@@ -25,10 +25,16 @@ from shipit.utils import download_file
 
 
 class LocalBuildBackend:
-    def __init__(self, src_dir: Path, assets_path: Path) -> None:
+    def __init__(
+        self,
+        src_dir: Path,
+        assets_path: Path,
+        shipit_dir: Optional[Path] = None,
+    ) -> None:
         self.src_dir = src_dir
         self.assets_path = assets_path
-        self.local_path = self.src_dir / ".shipit" / "local"
+        self.shipit_dir = shipit_dir or self.src_dir / ".shipit"
+        self.local_path = self.shipit_dir / "local"
         self.build_path = self.local_path / "build"
         self.workdir = self.build_path
         self.runtime_path: Optional[str] = None
@@ -46,7 +52,7 @@ class LocalBuildBackend:
         return self.get_mount_path(name)
 
     def get_volume_path(self, name: str) -> Path:
-        return self.src_dir / ".shipit" / "volumes" / name
+        return self.shipit_dir / "volumes" / name
 
     def execute_step(self, step: Step, env: Dict[str, str]) -> None:
         build_path = self.workdir

{shipit_cli-0.21.0 → shipit_cli-0.21.2}/src/shipit/cli.py

@@ -79,6 +79,13 @@ def default_shipit_path(project_paths: ProjectPaths) -> Path:
     )
 
 
+def default_shipit_dir(project_paths: ProjectPaths) -> Path:
+    shipit_dir = project_paths.workspace_root / ".shipit"
+    if project_paths.subdir is None:
+        return shipit_dir
+    return shipit_dir / shipit_subdir_slug(project_paths.subdir)
+
+
 def resolve_project_paths(path: Path, subdir: Optional[Path] = None) -> ProjectPaths:
     workspace_root = path.resolve()
     if subdir is None:
@@ -673,6 +680,7 @@ def auto(
     ):
         run(
             project_paths.workspace_root,
+            subdir=Path(project_paths.subdir) if project_paths.subdir else None,
             wasmer=wasmer,
             wasmer_bin=wasmer_bin,
             docker=docker,
@@ -685,10 +693,11 @@ def auto(
             wasmer_registry=wasmer_registry,
             serve_port=serve_port,
         )
-    
+
     if wasmer_deploy or wasmer_deploy_config:
         deploy(
             project_paths.workspace_root,
+            subdir=Path(project_paths.subdir) if project_paths.subdir else None,
             wasmer_deploy=wasmer_deploy,
             wasmer_deploy_config=wasmer_deploy_config,
             wasmer_bin=wasmer_bin,
@@ -809,6 +818,11 @@ def deploy(
         help="Project path (defaults to current directory).",
         show_default=False,
     ),
+    subdir: Optional[Path] = typer.Option(
+        None,
+        "--subdir",
+        help="App subdirectory relative to the project path.",
+    ),
     wasmer_deploy: bool = typer.Option(
         True,
         help="Deploy the project to Wasmer.",
@@ -840,14 +854,21 @@ def deploy(
 ) -> None:
     if not path.exists():
         raise Exception(f"The path {path} does not exist")
+    project_paths = resolve_project_paths(path, subdir)
+    shipit_dir = default_shipit_dir(project_paths)
 
-    build_backend = LocalBuildBackend(path, ASSETS_PATH)
+    build_backend = LocalBuildBackend(
+        project_paths.workspace_root,
+        ASSETS_PATH,
+        shipit_dir=shipit_dir,
+    )
     runner = WasmerRunner(
         build_backend,
-        path,
+        project_paths.workspace_root,
         registry=wasmer_registry,
         token=wasmer_token,
         bin=wasmer_bin,
+        shipit_dir=shipit_dir,
     )
 
     if wasmer_deploy_config:
@@ -863,6 +884,11 @@ def run(
         help="Project path (defaults to current directory).",
         show_default=False,
     ),
+    subdir: Optional[Path] = typer.Option(
+        None,
+        "--subdir",
+        help="App subdirectory relative to the project path.",
+    ),
     wasmer: bool = typer.Option(
         False,
         help="Use Wasmer to run the project.",
@@ -915,23 +941,38 @@ def run(
 ) -> None:
     if not path.exists():
         raise Exception(f"The path {path} does not exist")
+    project_paths = resolve_project_paths(path, subdir)
+    shipit_dir = default_shipit_dir(project_paths)
 
     if docker or docker_client:
         build_backend: BuildBackend = DockerBuildBackend(
-            path, ASSETS_PATH, docker_client, docker_opts
+            project_paths.workspace_root,
+            ASSETS_PATH,
+            docker_client,
+            docker_opts,
+            shipit_dir=shipit_dir,
         )
     else:
-        build_backend = LocalBuildBackend(path, ASSETS_PATH)
+        build_backend = LocalBuildBackend(
+            project_paths.workspace_root,
+            ASSETS_PATH,
+            shipit_dir=shipit_dir,
+        )
 
     if wasmer:
         runner: Runner = WasmerRunner(
             build_backend,
-            path,
+            project_paths.workspace_root,
             registry=wasmer_registry,
             bin=wasmer_bin,
+            shipit_dir=shipit_dir,
         )
     else:
-        runner = LocalRunner(build_backend, path)
+        runner = LocalRunner(
+            build_backend,
+            project_paths.workspace_root,
+            shipit_dir=shipit_dir,
+        )
 
     commands_to_run = resolve_run_commands(
         command_names=command_names,
@@ -941,11 +982,12 @@ def run(
 
     if commands_to_run:
         run_serve_commands(
-            path,
+            project_paths.workspace_root,
             runner,
             commands_to_run,
             volume_specs=volume_specs,
             env=runtime_serve_env(serve_port),
+            shipit_dir=shipit_dir,
         )
     else:
         console.print("[bold]No commands specified. Use `--command` to run a command.[/bold]")
@@ -1066,13 +1108,21 @@ def plan(
             project_paths.workspace_root,
             read_shipit_subdir(shipit_file),
         )
+    shipit_dir = default_shipit_dir(project_paths)
 
     if docker or docker_client:
         build_backend: BuildBackend = DockerBuildBackend(
-            project_paths.workspace_root, ASSETS_PATH, docker_client
+            project_paths.workspace_root,
+            ASSETS_PATH,
+            docker_client,
+            shipit_dir=shipit_dir,
         )
     else:
-        build_backend = LocalBuildBackend(project_paths.workspace_root, ASSETS_PATH)
+        build_backend = LocalBuildBackend(
+            project_paths.workspace_root,
+            ASSETS_PATH,
+            shipit_dir=shipit_dir,
+        )
     if wasmer:
         runner: Runner = WasmerRunner(
             build_backend,
@@ -1080,9 +1130,14 @@ def plan(
             registry=wasmer_registry,
             token=wasmer_token,
             bin=wasmer_bin,
+            shipit_dir=shipit_dir,
         )
     else:
-        runner = LocalRunner(build_backend, project_paths.workspace_root)
+        runner = LocalRunner(
+            build_backend,
+            project_paths.workspace_root,
+            shipit_dir=shipit_dir,
+        )
 
     base_config = Config()
     base_config.commands.enrich_from_path(project_paths.app_path)
@@ -1244,6 +1299,7 @@ def build(
             path,
             read_shipit_subdir(shipit_file),
         )
+    shipit_dir = default_shipit_dir(project_paths)
 
     if docker or docker_client:
         build_backend: BuildBackend = DockerBuildBackend(
@@ -1251,9 +1307,14 @@ def build(
             ASSETS_PATH,
             docker_client,
             docker_opts=docker_opts,
+            shipit_dir=shipit_dir,
         )
     else:
-        build_backend = LocalBuildBackend(project_paths.workspace_root, ASSETS_PATH)
+        build_backend = LocalBuildBackend(
+            project_paths.workspace_root,
+            ASSETS_PATH,
+            shipit_dir=shipit_dir,
+        )
     if wasmer:
         runner: Runner = WasmerRunner(
             build_backend,
@@ -1261,9 +1322,14 @@ def build(
             registry=wasmer_registry,
             token=wasmer_token,
             bin=wasmer_bin,
+            shipit_dir=shipit_dir,
         )
     else:
-        runner = LocalRunner(build_backend, project_paths.workspace_root)
+        runner = LocalRunner(
+            build_backend,
+            project_paths.workspace_root,
+            shipit_dir=shipit_dir,
+        )
 
     base_config = Config()
     base_config.commands.enrich_from_path(project_paths.app_path)
@@ -1344,7 +1410,7 @@ def build(
 
     # Build and serve
     build_backend.build(serve.name, env, serve.mounts or [], build_steps)
-    build_volumes(project_paths.workspace_root, serve)
+    build_volumes(project_paths.workspace_root, serve, shipit_dir=shipit_dir)
     runner.build(serve)
     if serve.prepare and not skip_prepare:
         console.print("\n[bold]Running prepare step[/bold]")
@@ -1390,9 +1456,10 @@ def run_serve_commands(
     commands: List[str],
     volume_specs: Optional[List[str]] = None,
     env: Optional[Dict[str, str]] = None,
+    shipit_dir: Optional[Path] = None,
 ) -> None:
     volume_mappings = merge_volume_mappings(
-        load_volume_mappings(path),
+        load_volume_mappings(path, shipit_dir=shipit_dir),
         parse_cli_volume_mappings(volume_specs),
     )
     for command in commands:

{shipit_cli-0.21.0 → shipit_cli-0.21.2}/src/shipit/runners/local.py

@@ -18,10 +18,16 @@ if TYPE_CHECKING:
 
 
 class LocalRunner:
-    def __init__(self, build_backend: BuildBackend, src_dir: Path) -> None:
+    def __init__(
+        self,
+        build_backend: BuildBackend,
+        src_dir: Path,
+        shipit_dir: Optional[Path] = None,
+    ) -> None:
         self.build_backend = build_backend
         self.src_dir = src_dir
-        self.runner_path = self.src_dir / ".shipit" / "runner" / "local"
+        self.shipit_dir = shipit_dir or self.src_dir / ".shipit"
+        self.runner_path = self.shipit_dir / "runner" / "local"
         self.serve_bin_path = self.runner_path / "bin"
         self.prepare_bash_script = self.runner_path / "prepare" / "prepare.sh"
 

{shipit_cli-0.21.0 → shipit_cli-0.21.2}/src/shipit/runners/wasmer.py

@@ -167,28 +167,28 @@ class WasmerRunner:
         },
         "phpix": {
             "dependencies": {
-                "latest": "phpix/phpix-83-32bit@=0.2.0-rc.6",
-                "8.3": "phpix/phpix-83-32bit@=0.2.0-rc.6",
-                "8.3.29": "phpix/phpix-83-32bit@=0.2.0-rc.6",
-                "8.2": "phpix/phpix-82-32bit@=0.2.0-rc.6",
-                "8.1": "phpix/phpix-81-32bit@=0.2.0-rc.6",
+                "latest": "phpix/phpix-83-32bit@=0.2.0",
+                "8.3": "phpix/phpix-83-32bit@=0.2.0",
+                "8.3.29": "phpix/phpix-83-32bit@=0.2.0",
+                "8.2": "phpix/phpix-82-32bit@=0.2.0",
+                "8.1": "phpix/phpix-81-32bit@=0.2.0",
                 "7.4": "php/php-32@=7.4.3301", # Note, we don't have PHPix + PHP 7.4 and never will
             },
             "architecture_dependencies": {
                 "64-bit": {
-                    "latest": "phpix/phpix-83-64bit@=0.2.0-rc.6",
-                    "8.3": "phpix/phpix-83-64bit@=0.2.0-rc.6",
-                    "8.3.29": "phpix/phpix-83-64bit@=0.2.0-rc.6",
-                    "8.2": "phpix/phpix-82-64bit@=0.2.0-rc.6",
-                    "8.1": "phpix/phpix-81-64bit@=0.2.0-rc.6",
+                    "latest": "phpix/phpix-83-64bit@=0.2.0",
+                    "8.3": "phpix/phpix-83-64bit@=0.2.0",
+                    "8.3.29": "phpix/phpix-83-64bit@=0.2.0",
+                    "8.2": "phpix/phpix-82-64bit@=0.2.0",
+                    "8.1": "phpix/phpix-81-64bit@=0.2.0",
                     "7.4": "php/php-64@=7.4.3301",
                 },
                 "32-bit": {
-                    "latest": "phpix/phpix-83-32bit@=0.2.0-rc.6",
-                    "8.3": "phpix/phpix-83-32bit@=0.2.0-rc.6",
-                    "8.3.29": "phpix/phpix-83-32bit@=0.2.0-rc.6",
-                    "8.2": "phpix/phpix-82-32bit@=0.2.0-rc.6",
-                    "8.1": "phpix/phpix-81-32bit@=0.2.0-rc.6",
+                    "latest": "phpix/phpix-83-32bit@=0.2.0",
+                    "8.3": "phpix/phpix-83-32bit@=0.2.0",
+                    "8.3.29": "phpix/phpix-83-32bit@=0.2.0",
+                    "8.2": "phpix/phpix-82-32bit@=0.2.0",
+                    "8.1": "phpix/phpix-81-32bit@=0.2.0",
                     "7.4": "php/php-32@=7.4.3301",
                 },
             },
@@ -224,10 +224,12 @@ class WasmerRunner:
         registry: Optional[str] = None,
         token: Optional[str] = None,
         bin: Optional[str] = None,
+        shipit_dir: Optional[Path] = None,
     ) -> None:
         self.build_backend = build_backend
         self.src_dir = src_dir
-        self.wasmer_dir_path = self.src_dir / ".shipit" / "wasmer"
+        self.shipit_dir = shipit_dir or self.src_dir / ".shipit"
+        self.wasmer_dir_path = self.shipit_dir / "wasmer"
         self.wasmer_registry = registry
         self.wasmer_token = token
         self.bin = bin or "wasmer"
@@ -342,7 +344,7 @@ class WasmerRunner:
         self.run_serve_command(
             "bash /prepare/prepare.sh",
             volume_mappings={
-                **load_volume_mappings(self.src_dir),
+                **load_volume_mappings(self.src_dir, shipit_dir=self.shipit_dir),
                 "/prepare": prepare_dir,
             },
         )

shipit_cli-0.21.2/src/shipit/version.py

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

{shipit_cli-0.21.0 → shipit_cli-0.21.2}/src/shipit/volumes.py

@@ -1,22 +1,29 @@
 import json
 import shutil
 from pathlib import Path
-from typing import Dict
+from typing import Dict, Optional
 
 from shipit.builders.base import BuildBackend
 from shipit.shipit_types import Serve, Volume
 
 
-def get_volumes_dir(src_dir: Path) -> Path:
-    return src_dir / ".shipit" / "volumes"
+def get_volumes_dir(src_dir: Path, shipit_dir: Optional[Path] = None) -> Path:
+    return (shipit_dir or src_dir / ".shipit") / "volumes"
 
 
-def get_volume_mappings_path(src_dir: Path) -> Path:
-    return get_volumes_dir(src_dir) / "mappings.json"
+def get_volume_mappings_path(
+    src_dir: Path,
+    shipit_dir: Optional[Path] = None,
+) -> Path:
+    return get_volumes_dir(src_dir, shipit_dir=shipit_dir) / "mappings.json"
 
 
-def build_volumes(src_dir: Path, serve: Serve) -> Dict[str, str]:
-    volumes_dir = get_volumes_dir(src_dir)
+def build_volumes(
+    src_dir: Path,
+    serve: Serve,
+    shipit_dir: Optional[Path] = None,
+) -> Dict[str, str]:
+    volumes_dir = get_volumes_dir(src_dir, shipit_dir=shipit_dir)
     volumes_dir.mkdir(parents=True, exist_ok=True)
 
     mappings = {
@@ -25,17 +32,20 @@ def build_volumes(src_dir: Path, serve: Serve) -> Dict[str, str]:
     }
     for volume in serve.volumes or []:
         volume.path.mkdir(parents=True, exist_ok=True)
-        if _should_link_local_volume(src_dir, volume):
+        if _should_link_local_volume(src_dir, volume, shipit_dir=shipit_dir):
             _link_local_volume(volume)
 
-    get_volume_mappings_path(src_dir).write_text(
+    get_volume_mappings_path(src_dir, shipit_dir=shipit_dir).write_text(
         json.dumps(mappings, indent=2, sort_keys=True) + "\n"
     )
     return mappings
 
 
-def load_volume_mappings(src_dir: Path) -> Dict[str, str]:
-    mappings_path = get_volume_mappings_path(src_dir)
+def load_volume_mappings(
+    src_dir: Path,
+    shipit_dir: Optional[Path] = None,
+) -> Dict[str, str]:
+    mappings_path = get_volume_mappings_path(src_dir, shipit_dir=shipit_dir)
     if not mappings_path.is_file():
         return {}
 
@@ -98,8 +108,12 @@ def _parse_volume_spec(spec: str) -> tuple[str, str]:
     return name, guest_path
 
 
-def _should_link_local_volume(src_dir: Path, volume: Volume) -> bool:
-    shipit_dir = (src_dir / ".shipit").absolute()
+def _should_link_local_volume(
+    src_dir: Path,
+    volume: Volume,
+    shipit_dir: Optional[Path] = None,
+) -> bool:
+    shipit_dir = (shipit_dir or src_dir / ".shipit").absolute()
     return volume.serve_path.is_absolute() and volume.serve_path.is_relative_to(
         shipit_dir
     )

{shipit_cli-0.21.0 → shipit_cli-0.21.2}/tests/test_subdir.py

@@ -52,20 +52,26 @@ def _patch_fake_build_runner(monkeypatch: pytest.MonkeyPatch):
     runner_instances = []
 
     class FakeBuildBackend:
-        def __init__(self, src_dir: Path, assets_path: Path) -> None:
+        def __init__(
+            self,
+            src_dir: Path,
+            assets_path: Path,
+            shipit_dir: Path | None = None,
+        ) -> None:
             self.src_dir = src_dir
             self.assets_path = assets_path
+            self.shipit_dir = shipit_dir or src_dir / ".shipit"
             self.runtime_path = None
             build_backend_instances.append(self)
 
         def get_build_mount_path(self, name: str) -> Path:
-            return self.src_dir / ".shipit" / "fake" / "build" / name
+            return self.shipit_dir / "fake" / "build" / name
 
         def get_artifact_mount_path(self, name: str) -> Path:
             return self.get_build_mount_path(name)
 
         def get_volume_path(self, name: str) -> Path:
-            return self.src_dir / ".shipit" / "volumes" / name
+            return self.shipit_dir / "volumes" / name
 
         def get_runtime_path(self) -> str | None:
             return self.runtime_path
@@ -79,9 +85,16 @@ def _patch_fake_build_runner(monkeypatch: pytest.MonkeyPatch):
             }
 
     class FakeRunner:
-        def __init__(self, build_backend, src_dir: Path) -> None:
+        def __init__(
+            self,
+            build_backend,
+            src_dir: Path,
+            shipit_dir: Path | None = None,
+        ) -> None:
             self.build_backend = build_backend
             self.src_dir = src_dir
+            self.shipit_dir = shipit_dir or src_dir / ".shipit"
+            self.calls = []
             runner_instances.append(self)
 
         def prepare_config(self, provider_config):
@@ -99,6 +112,23 @@ def _patch_fake_build_runner(monkeypatch: pytest.MonkeyPatch):
         def prepare(self, env, prepare) -> None:
             self.prepare_args = (env, prepare)
 
+        def has_serve_command(self, command: str) -> bool:
+            return True
+
+        def run_serve_command(
+            self,
+            command: str,
+            volume_mappings=None,
+            env=None,
+        ) -> None:
+            self.calls.append(
+                {
+                    "command": command,
+                    "volume_mappings": volume_mappings,
+                    "env": env,
+                }
+            )
+
     monkeypatch.setattr(cli, "LocalBuildBackend", FakeBuildBackend)
     monkeypatch.setattr(cli, "LocalRunner", FakeRunner)
     return build_backend_instances, runner_instances
@@ -430,6 +460,12 @@ def test_build_recovers_subdir_from_generated_shipit(
 
     assert result.exit_code == 0, result.output
     assert build_backend_instances[-1].src_dir == tmp_path.resolve()
+    assert build_backend_instances[-1].shipit_dir == (
+        tmp_path.resolve() / ".shipit" / "apps-site"
+    )
+    assert runner_instances[-1].shipit_dir == (
+        tmp_path.resolve() / ".shipit" / "apps-site"
+    )
     serve = runner_instances[-1].serve
     assert serve.cwd.endswith("/app")
     install_step = next(
@@ -463,9 +499,107 @@ def test_build_subdir_uses_app_specific_shipit_by_default(
 
     assert result.exit_code == 0, result.output
     assert build_backend_instances[-1].src_dir == tmp_path.resolve()
+    assert build_backend_instances[-1].shipit_dir == (
+        tmp_path.resolve() / ".shipit" / "apps-site"
+    )
+    assert runner_instances[-1].shipit_dir == (
+        tmp_path.resolve() / ".shipit" / "apps-site"
+    )
     assert runner_instances[-1].serve.cwd.endswith("/app")
 
 
+def test_run_subdir_uses_app_specific_shipit_dir(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _write_node_workspace(tmp_path)
+    build_backend_instances, runner_instances = _patch_fake_build_runner(
+        monkeypatch
+    )
+
+    result = runner.invoke(
+        cli.app,
+        ["run", str(tmp_path), "--subdir=apps/site", "--start"],
+    )
+
+    assert result.exit_code == 0, result.output
+    assert build_backend_instances[-1].shipit_dir == (
+        tmp_path.resolve() / ".shipit" / "apps-site"
+    )
+    assert runner_instances[-1].shipit_dir == (
+        tmp_path.resolve() / ".shipit" / "apps-site"
+    )
+    assert runner_instances[-1].calls == [
+        {
+            "command": "start",
+            "volume_mappings": {},
+            "env": {"PORT": "8080"},
+        }
+    ]
+
+
+def test_deploy_subdir_uses_app_specific_shipit_dir(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _write_node_workspace(tmp_path)
+    build_backend_instances, _runner_instances = _patch_fake_build_runner(
+        monkeypatch
+    )
+    wasmer_runner_instances = []
+
+    class FakeWasmerRunner:
+        def __init__(
+            self,
+            build_backend,
+            src_dir: Path,
+            registry=None,
+            token=None,
+            bin=None,
+            shipit_dir: Path | None = None,
+        ) -> None:
+            self.build_backend = build_backend
+            self.src_dir = src_dir
+            self.registry = registry
+            self.token = token
+            self.bin = bin
+            self.shipit_dir = shipit_dir or src_dir / ".shipit"
+            self.deploy_calls = []
+            wasmer_runner_instances.append(self)
+
+        def deploy_config(self, config_path: Path) -> None:
+            self.deploy_config_path = config_path
+
+        def deploy(self, app_owner=None, app_name=None) -> None:
+            self.deploy_calls.append(
+                {
+                    "app_owner": app_owner,
+                    "app_name": app_name,
+                }
+            )
+
+    monkeypatch.setattr(cli, "WasmerRunner", FakeWasmerRunner)
+
+    result = runner.invoke(
+        cli.app,
+        ["deploy", str(tmp_path), "--subdir=apps/site"],
+    )
+
+    assert result.exit_code == 0, result.output
+    assert build_backend_instances[-1].shipit_dir == (
+        tmp_path.resolve() / ".shipit" / "apps-site"
+    )
+    assert wasmer_runner_instances[-1].shipit_dir == (
+        tmp_path.resolve() / ".shipit" / "apps-site"
+    )
+    assert wasmer_runner_instances[-1].deploy_calls == [
+        {
+            "app_owner": None,
+            "app_name": None,
+        }
+    ]
+
+
 def test_plan_accepts_subdir_and_reports_app_provider(tmp_path: Path) -> None:
     _write_node_workspace(tmp_path)
 
@@ -537,6 +671,52 @@ def test_auto_passes_subdir_to_generate_and_build(
     assert not (tmp_path / "Shipit").exists()
 
 
+def test_auto_passes_subdir_to_run_and_deploy(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _write_node_workspace(tmp_path)
+    calls = {}
+
+    def fake_generate(path: Path, **kwargs) -> None:
+        calls["generate"] = (path, kwargs)
+        out = kwargs["out"] or cli.default_shipit_path(
+            cli.resolve_project_paths(path, kwargs["subdir"])
+        )
+        out.write_text('app_subdir = "apps/site"\n')
+
+    def fake_build(path: Path, **kwargs) -> None:
+        calls["build"] = (path, kwargs)
+
+    def fake_run(path: Path, **kwargs) -> None:
+        calls["run"] = (path, kwargs)
+
+    def fake_deploy(path: Path, **kwargs) -> None:
+        calls["deploy"] = (path, kwargs)
+
+    monkeypatch.setattr(cli, "generate", fake_generate)
+    monkeypatch.setattr(cli, "build", fake_build)
+    monkeypatch.setattr(cli, "run", fake_run)
+    monkeypatch.setattr(cli, "deploy", fake_deploy)
+
+    result = runner.invoke(
+        cli.app,
+        [
+            "auto",
+            str(tmp_path),
+            "--subdir=apps/site",
+            "--start",
+            "--wasmer-deploy",
+        ],
+    )
+
+    assert result.exit_code == 0, result.output
+    assert calls["run"][0] == tmp_path.resolve()
+    assert calls["run"][1]["subdir"] == Path("apps/site")
+    assert calls["deploy"][0] == tmp_path.resolve()
+    assert calls["deploy"][1]["subdir"] == Path("apps/site")
+
+
 @pytest.mark.parametrize(
     "subdir",
     [

{shipit_cli-0.21.0 → shipit_cli-0.21.2}/tests/test_volumes.py

@@ -89,6 +89,43 @@ def test_build_volumes_links_runtime_volume_to_host_directory(
     assert load_volume_mappings(tmp_path) == {"wp-content": str(target)}
 
 
+def test_build_volumes_can_use_namespaced_shipit_directory(
+    tmp_path: Path,
+) -> None:
+    src_dir = tmp_path / "src"
+    src_dir.mkdir()
+    assets_path = tmp_path / "assets"
+    assets_path.mkdir()
+    shipit_dir = src_dir / ".shipit" / "apps-site"
+    build_backend = LocalBuildBackend(src_dir, assets_path, shipit_dir=shipit_dir)
+
+    target = build_backend.get_artifact_mount_path("app") / "wp-content"
+    target.mkdir(parents=True, exist_ok=True)
+
+    volume = Volume(
+        name="wp-content",
+        path=build_backend.get_volume_path("wp-content"),
+        serve_path=target,
+    )
+    serve = Serve(
+        name="wordpress",
+        provider="wordpress",
+        build=[],
+        deps=[],
+        commands={"start": "php -S localhost:8080 -t /app"},
+        volumes=[volume],
+    )
+
+    mappings = build_volumes(src_dir, serve, shipit_dir=shipit_dir)
+
+    assert volume.path == shipit_dir / "volumes" / "wp-content"
+    assert mappings == {"wp-content": str(target)}
+    assert load_volume_mappings(src_dir, shipit_dir=shipit_dir) == {
+        "wp-content": str(target)
+    }
+    assert not (src_dir / ".shipit" / "volumes" / "mappings.json").exists()
+
+
 def test_wasmer_runner_passes_volume_paths_into_wasmer_run(
     tmp_path: Path,
     monkeypatch: pytest.MonkeyPatch,

shipit_cli-0.21.0/src/shipit/version.py

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