shipit-cli 0.14.0__py3-none-any.whl → 0.15.1__py3-none-any.whl

shipit/providers/laravel.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 from pathlib import Path
 from typing import Dict, Optional
 
@@ -12,65 +10,76 @@ from .base import (
     ServiceSpec,
     VolumeSpec,
     CustomCommands,
+    Config,
 )
+from .php import PhpConfig, PhpProvider
+from .node_static import NodeStaticConfig, NodeStaticProvider
+from pydantic_settings import SettingsConfigDict
+
+
+class LaravelConfig(PhpConfig, NodeStaticConfig):
+    model_config = SettingsConfigDict(extra="ignore", env_prefix="SHIPIT_")
 
 
-class LaravelProvider:
-    def __init__(self, path: Path, custom_commands: CustomCommands):
+class LaravelProvider(PhpProvider):
+    def __init__(self, path: Path, config: LaravelConfig):
         self.path = path
-        self.custom_commands = custom_commands
+        self.node_provider = NodeStaticProvider(path, config, only_build=True)
+        self.config = config
+
+    @classmethod
+    def load_config(cls, path: Path, base_config: Config) -> LaravelConfig:
+        config = super().load_config(path, base_config)
+        node_config = NodeStaticProvider.load_config(path, base_config)
+        node_config.static_dir = None
+        node_config.static_generator = None
+        return LaravelConfig(
+            **(
+                config.model_dump()
+                | node_config.model_dump()
+                | base_config.model_dump()
+            )
+        )
 
     @classmethod
     def name(cls) -> str:
         return "laravel"
 
     @classmethod
-    def detect(cls, path: Path, custom_commands: CustomCommands) -> Optional[DetectResult]:
+    def detect(cls, path: Path, config: Config) -> Optional[DetectResult]:
         if _exists(path, "artisan") and _exists(path, "composer.json"):
             return DetectResult(cls.name(), 95)
         return None
 
-    def initialize(self) -> None:
-        pass
-
     def serve_name(self) -> Optional[str]:
         return None
 
-    def platform(self) -> Optional[str]:
-        return "laravel"
-
     def dependencies(self) -> list[DependencySpec]:
         return [
             DependencySpec(
                 "php",
-                env_var="SHIPIT_PHP_VERSION",
-                default_version="8.3",
+                var_name="config.php_version",
                 use_in_build=True,
                 use_in_serve=True,
             ),
             DependencySpec("composer", use_in_build=True),
-            DependencySpec("pie", use_in_build=True),
-            DependencySpec("pnpm", use_in_build=True),
+            # DependencySpec("pie", use_in_build=True),
+            *self.node_provider.dependencies(),
             DependencySpec("bash", use_in_serve=True),
         ]
 
-    def declarations(self) -> Optional[str]:
-        return "HOME = getenv(\"HOME\")"
-
     def build_steps(self) -> list[str]:
         return [
-            "env(HOME=HOME, COMPOSER_FUND=\"0\")",
-            "workdir(app[\"build\"])",
-            "run(\"pie install php/pdo_pgsql\")",
-            "run(\"composer install --optimize-autoloader --no-scripts --no-interaction\", inputs=[\"composer.json\", \"composer.lock\", \"artisan\"], outputs=[\".\"], group=\"install\")",
-            "run(\"pnpm install\", inputs=[\"package.json\", \"package-lock.json\"], outputs=[\".\"], group=\"install\")",
-            "copy(\".\", \".\", ignore=[\".git\"])",
-            "run(\"pnpm run build\", outputs=[\".\"], group=\"build\")",
+            'env(COMPOSER_HOME="/tmp", COMPOSER_FUND="0")',
+            'workdir(app.path)',
+            # "run(\"pie install php/pdo_pgsql\")",
+            'run("composer install --optimize-autoloader --no-scripts --no-interaction", inputs=["composer.json", "composer.lock", "artisan"], outputs=["."], group="install")',
+            *self.node_provider.build_steps(),
         ]
 
     def prepare_steps(self) -> Optional[list[str]]:
         return [
-            'workdir(app["serve"])',
+            'workdir(app.serve_path)',
             'run("mkdir -p storage/framework/{sessions,views,cache,testing} storage/logs bootstrap/cache")',
             'run("php artisan config:cache")',
             'run("php artisan event:cache")',
@@ -85,13 +94,13 @@ class LaravelProvider:
         }
 
     def mounts(self) -> list[MountSpec]:
-        return [MountSpec("app")]
+        return [MountSpec("app"), *self.node_provider.mounts()]
 
     def volumes(self) -> list[VolumeSpec]:
         return []
 
     def env(self) -> Optional[Dict[str, str]]:
         return None
-    
+
     def services(self) -> list[ServiceSpec]:
         return []

shipit/providers/mkdocs.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 from pathlib import Path
 from typing import Dict, Optional
 
@@ -12,37 +10,54 @@ from .base import (
     ServiceSpec,
     VolumeSpec,
     CustomCommands,
+    Config,
 )
-from .staticfile import StaticFileProvider
-from .python import PythonProvider
+from .staticfile import StaticFileProvider, StaticFileConfig
+from .python import PythonProvider, PythonConfig
+from pydantic_settings import SettingsConfigDict
+
+
+class MkdocsConfig(PythonConfig, StaticFileConfig):
+    model_config = SettingsConfigDict(extra="ignore", env_prefix="SHIPIT_")
+
+    mkdocs_version: Optional[str] = None
 
 
 class MkdocsProvider(StaticFileProvider):
-    def __init__(self, path: Path, custom_commands: CustomCommands):
+    def __init__(self, path: Path, config: MkdocsConfig):
         self.path = path
-        self.python_provider = PythonProvider(path, custom_commands, only_build=True, extra_dependencies={"mkdocs"})
+        self.python_provider = PythonProvider(path, config, only_build=True)
+
+    @classmethod
+    def load_config(cls, path: Path, base_config: Config) -> MkdocsConfig:
+        python_config = PythonProvider.load_config(
+            path, base_config, must_have_deps={"mkdocs"}
+        )
+        staticfile_config = StaticFileProvider.load_config(path, base_config)
+
+        return MkdocsConfig(
+            **(
+                python_config.model_dump()
+                | staticfile_config.model_dump()
+                | base_config.model_dump()
+            )
+        )
 
     @classmethod
     def name(cls) -> str:
         return "mkdocs"
 
     @classmethod
-    def detect(cls, path: Path, custom_commands: CustomCommands) -> Optional[DetectResult]:
+    def detect(cls, path: Path, config: Config) -> Optional[DetectResult]:
         if _exists(path, "mkdocs.yml", "mkdocs.yaml"):
             return DetectResult(cls.name(), 85)
-        if custom_commands.build and custom_commands.build.startswith("mkdocs "):
+        if config.commands.build and config.commands.build.startswith("mkdocs "):
             return DetectResult(cls.name(), 85)
         return None
 
-    def initialize(self) -> None:
-        pass
-
     def serve_name(self) -> Optional[str]:
         return None
 
-    def platform(self) -> Optional[str]:
-        return None
-
     def dependencies(self) -> list[DependencySpec]:
         return [
             *self.python_provider.dependencies(),
@@ -50,25 +65,25 @@ class MkdocsProvider(StaticFileProvider):
         ]
 
     def declarations(self) -> Optional[str]:
-        return "mkdocs_version = getenv(\"SHIPIT_MKDOCS_VERSION\") or \"1.6.1\"\n" + (self.python_provider.declarations() or "")
+        return self.python_provider.declarations() or ""
 
     def build_steps(self) -> list[str]:
         return [
             *self.python_provider.build_steps(),
-            "run(\"uv run mkdocs build --site-dir={}\".format(app[\"build\"]), outputs=[\".\"], group=\"build\")",
+            'run("uv run mkdocs build --site-dir={}".format(static_app.path), outputs=["."], group="build")',
         ]
 
     def prepare_steps(self) -> Optional[list[str]]:
         return self.python_provider.prepare_steps()
 
     def mounts(self) -> list[MountSpec]:
-        return [MountSpec("app"), *self.python_provider.mounts()]
+        return [*self.python_provider.mounts(), *super().mounts()]
 
     def volumes(self) -> list[VolumeSpec]:
         return []
 
     def env(self) -> Optional[Dict[str, str]]:
         return self.python_provider.env()
-    
+
     def services(self) -> list[ServiceSpec]:
         return []

shipit/providers/node_static.py

@@ -1,11 +1,10 @@
-from __future__ import annotations
-
 import json
 import yaml
 from pathlib import Path
-from typing import Dict, Optional, Any, Set
+from typing import Dict, Optional, Any, Set, List
 from enum import Enum
 from semantic_version import Version, NpmSpec
+from pydantic import Field
 
 
 from .base import (
@@ -15,9 +14,10 @@ from .base import (
     MountSpec,
     ServiceSpec,
     VolumeSpec,
-    CustomCommands,
+    Config,
 )
-from .staticfile import StaticFileProvider
+from .staticfile import StaticFileProvider, StaticFileConfig
+from pydantic_settings import SettingsConfigDict
 
 
 class PackageManager(Enum):
@@ -46,7 +46,7 @@ class PackageManager(Enum):
 
         return DependencySpec(
             dep_name,
-            env_var=f"SHIPIT_{dep_name.upper()}_VERSION",
+            var_name=f"config.{dep_name.lower()}_version",
             default_version=default_version,
         )
 
@@ -114,60 +114,146 @@ class StaticGenerator(Enum):
     REMIX_OLD = "remix-old"
     REMIX_V2 = "remix-v2"
 
+    def get_output_dir(self) -> str:
+        if self == StaticGenerator.NEXT:
+            return "out"
+        elif self == StaticGenerator.NUXT_V3:
+            return ".output/public"
+        elif self in [
+            StaticGenerator.ASTRO,
+            StaticGenerator.VITE,
+            StaticGenerator.NUXT_OLD,
+            StaticGenerator.REMIX_V2,
+        ]:
+            return "dist"
+        elif self == StaticGenerator.GATSBY:
+            return "public"
+        elif self == StaticGenerator.REMIX_OLD:
+            return "build/client"
+        elif self in [
+            StaticGenerator.DOCUSAURUS,
+            StaticGenerator.DOCUSAURUS_OLD,
+            StaticGenerator.SVELTE,
+        ]:
+            return "build"
+        else:
+            return "dist"
+
+    @classmethod
+    def detect_generators_from_command(cls, build_command) -> List["StaticGenerator"]:
+        commands = {
+            "gatsby": [StaticGenerator.GATSBY],
+            "astro": [StaticGenerator.ASTRO],
+            "remix-ssg": [StaticGenerator.REMIX_OLD],
+            "vite": [StaticGenerator.VITE, StaticGenerator.REMIX_V2],
+            "docusaurus": [StaticGenerator.DOCUSAURUS, StaticGenerator.DOCUSAURUS_OLD],
+            "next": [StaticGenerator.NEXT],
+            "nuxi": [StaticGenerator.NUXT_V3],
+            "nuxt": [StaticGenerator.NUXT_OLD],
+            "svelte-kit": [StaticGenerator.SVELTE],
+        }
+        build_command = build_command.split(" ")[0]
+        if build_command in commands:
+            return commands[build_command]
+        else:
+            return []
+    
+    def build_command(self) -> str:
+        return {
+            StaticGenerator.GATSBY: "gatsby build",
+            StaticGenerator.ASTRO: "astro build",
+            StaticGenerator.REMIX_OLD: "remix-ssg build",
+            StaticGenerator.REMIX_V2: "vite build",
+            StaticGenerator.DOCUSAURUS: "docusaurus build",
+            StaticGenerator.DOCUSAURUS_OLD: "docusaurus build",
+            StaticGenerator.SVELTE: "svelte-kit build",
+            StaticGenerator.VITE: "vite build",
+            StaticGenerator.NEXT: "next export",
+            StaticGenerator.NUXT_V3: "nuxi generate",
+            StaticGenerator.NUXT_OLD: "nuxt generate",
+            StaticGenerator.REMIX: "remix-ssg build",
+        }[self]
 
-class NodeStaticProvider(StaticFileProvider):
-    package_manager: PackageManager
-    package_json: Optional[Dict[str, Any]]
-    extra_dependencies: Set[str]
+
+class NodeStaticConfig(StaticFileConfig):
+    model_config = SettingsConfigDict(extra="ignore", env_prefix="SHIPIT_")
+
+    package_manager: Optional[PackageManager] = None
+    extra_dependencies: Set[str] = Field(default_factory=set)
     static_generator: Optional[StaticGenerator] = None
     build_command: Optional[str] = None
+    node_version: Optional[str] = "22"
+    npm_version: Optional[str] = None
+    pnpm_version: Optional[str] = None
+    yarn_version: Optional[str] = None
+    bun_version: Optional[str] = None
 
-    def __init__(self, path: Path, custom_commands: CustomCommands):
-        super().__init__(path, custom_commands)
-        if (path / "package-lock.json").exists():
-            self.package_manager = PackageManager.NPM
-        elif (path / "pnpm-lock.yaml").exists():
-            self.package_manager = PackageManager.PNPM
-        elif (path / "yarn.lock").exists():
-            self.package_manager = PackageManager.YARN
-        elif (path / "bun.lockb").exists():
-            self.package_manager = PackageManager.BUN
-        else:
-            self.package_manager = PackageManager.PNPM
-
-        self.package_json = self.parse_package_json(path)
-
-        if self.has_dependency(self.package_json, "gatsby"):
-            self.static_generator = StaticGenerator.GATSBY
-        elif self.has_dependency(self.package_json, "astro"):
-            self.static_generator = StaticGenerator.ASTRO
-        elif self.has_dependency(self.package_json, "docusaurus"):
-            self.static_generator = StaticGenerator.DOCUSAURUS_OLD
-        elif self.has_dependency(self.package_json, "@docusaurus/core"):
-            self.static_generator = StaticGenerator.DOCUSAURUS
-        elif self.has_dependency(self.package_json, "svelte"):
-            self.static_generator = StaticGenerator.SVELTE
-        elif self.has_dependency(
-            self.package_json, "@remix-run/dev", "1"
-        ) or self.has_dependency(self.package_json, "@remix-run/dev", "0"):
-            self.static_generator = StaticGenerator.REMIX_OLD
-        elif self.has_dependency(self.package_json, "@remix-run/dev"):
-            self.static_generator = StaticGenerator.REMIX_V2
-        elif self.has_dependency(self.package_json, "vite"):
-            self.static_generator = StaticGenerator.VITE
-        elif self.has_dependency(self.package_json, "next"):
-            self.static_generator = StaticGenerator.NEXT
-        elif self.has_dependency(self.package_json, "nuxt", "2") or self.has_dependency(
-            self.package_json, "nuxt", "1"
-        ):
-            self.static_generator = StaticGenerator.NUXT_OLD
-        elif self.has_dependency(self.package_json, "nuxt"):
-            self.static_generator = StaticGenerator.NUXT_V3
-
-        self.build_command = self.get_build_command(self.package_json, self.package_manager, self.static_generator)
-
-        # if self.has_dependency(self.package_json, "sharp"):
-        #     self.extra_dependencies.add("libvips")
+
+class NodeStaticProvider(StaticFileProvider):
+    only_build: bool = False
+
+    def __init__(
+        self, path: Path, config: NodeStaticConfig, only_build: bool = False
+    ):
+        super().__init__(path, config)
+        self.only_build = only_build
+
+    @classmethod
+    def load_config(
+        cls, path: Path, base_config: Config
+    ) -> NodeStaticConfig:
+        config = NodeStaticConfig(**base_config.model_dump())
+        if not config.package_manager:
+            if (path / "package-lock.json").exists():
+                config.package_manager = PackageManager.NPM
+            elif (path / "pnpm-lock.yaml").exists():
+                config.package_manager = PackageManager.PNPM
+            elif (path / "yarn.lock").exists():
+                config.package_manager = PackageManager.YARN
+            elif (path / "bun.lockb").exists():
+                config.package_manager = PackageManager.BUN
+            else:
+                config.package_manager = PackageManager.PNPM
+
+        package_json = cls.parse_package_json(path)
+
+        if not config.static_generator:
+            if cls.has_dependency(package_json, "gatsby"):
+                config.static_generator = StaticGenerator.GATSBY
+            elif cls.has_dependency(package_json, "astro"):
+                config.static_generator = StaticGenerator.ASTRO
+            elif cls.has_dependency(package_json, "docusaurus"):
+                config.static_generator = StaticGenerator.DOCUSAURUS_OLD
+            elif cls.has_dependency(package_json, "@docusaurus/core"):
+                config.static_generator = StaticGenerator.DOCUSAURUS
+            elif cls.has_dependency(package_json, "svelte"):
+                config.static_generator = StaticGenerator.SVELTE
+            elif cls.has_dependency(
+                package_json, "@remix-run/dev", "1"
+            ) or cls.has_dependency(package_json, "@remix-run/dev", "0"):
+                config.static_generator = StaticGenerator.REMIX_OLD
+            elif cls.has_dependency(package_json, "@remix-run/dev"):
+                config.static_generator = StaticGenerator.REMIX_V2
+            elif cls.has_dependency(package_json, "vite"):
+                config.static_generator = StaticGenerator.VITE
+            elif cls.has_dependency(package_json, "next"):
+                config.static_generator = StaticGenerator.NEXT
+            elif cls.has_dependency(package_json, "nuxt", "2") or cls.has_dependency(
+                package_json, "nuxt", "1"
+            ):
+                config.static_generator = StaticGenerator.NUXT_OLD
+            elif cls.has_dependency(package_json, "nuxt"):
+                config.static_generator = StaticGenerator.NUXT_V3
+
+        if not config.build_command:
+            config.build_command = cls.get_build_command(
+                package_json, config.package_manager, config.static_generator
+            )
+
+        if not config.static_dir:
+            config.static_dir = config.static_generator.get_output_dir()
+
+        return config
 
     @classmethod
     def parse_package_json(cls, path: Path) -> Optional[Dict[str, Any]]:
@@ -211,8 +297,27 @@ class NodeStaticProvider(StaticFileProvider):
 
     @classmethod
     def detect(
-        cls, path: Path, custom_commands: CustomCommands
+        cls, path: Path, config: Config
     ) -> Optional[DetectResult]:
+        if config.commands.install:
+            # Detect this provider from the install command
+            if config.commands.install in ["npm install", "npm ci", "npm i", "pnpm install", "pnpm ci", "pnpm i", "yarn install", "yarn ci", "yarn i", "bun install", "bun ci", "bun i"]:
+                return DetectResult(cls.name(), 40)
+
+        if config.commands.build:
+            if config.commands.build.startswith("npm run "):
+                return DetectResult(cls.name(), 40)
+            elif config.commands.build.startswith("pnpm run "):
+                return DetectResult(cls.name(), 40)
+            elif config.commands.build.startswith("yarn run "):
+                return DetectResult(cls.name(), 40)
+            elif config.commands.build.startswith("bun run "):
+                return DetectResult(cls.name(), 40)
+
+            static_generators = StaticGenerator.detect_generators_from_command(config.commands.build)
+            if static_generators:
+                return DetectResult(cls.name(), 40)
+
         package_json = cls.parse_package_json(path)
         if not package_json:
             return None
@@ -231,119 +336,80 @@ class NodeStaticProvider(StaticFileProvider):
             return DetectResult(cls.name(), 40)
         return None
 
-    def initialize(self) -> None:
-        pass
-
     def serve_name(self) -> Optional[str]:
         return None
 
-    def platform(self) -> Optional[str]:
-        return self.static_generator.value if self.static_generator else None
-
     def dependencies(self) -> list[DependencySpec]:
-        package_manager_dep = self.package_manager.as_dependency(self.path)
+        package_manager_dep = self.config.package_manager.as_dependency(self.path)
         package_manager_dep.use_in_build = True
         return [
             DependencySpec(
                 "node",
-                env_var="SHIPIT_NODE_VERSION",
-                default_version="22",
+                var_name="config.node_version",
                 use_in_build=True,
             ),
             package_manager_dep,
-            DependencySpec("static-web-server", use_in_serve=True),
+            *super().dependencies(),
         ]
 
-    def declarations(self) -> Optional[str]:
-        output_dir = self.get_output_dir()
-        return (
-            f'shipit_static_dir = getenv("SHIPIT_STATIC_DIR") or "{output_dir}"\n'
-        )
-
-    def get_output_dir(self) -> str:
-        if self.static_generator == StaticGenerator.NEXT:
-            return "out"
-        elif self.static_generator in [
-            StaticGenerator.ASTRO,
-            StaticGenerator.VITE,
-            StaticGenerator.NUXT_OLD,
-            StaticGenerator.NUXT_V3,
-            StaticGenerator.REMIX_V2,
-        ]:
-            return "dist"
-        elif self.static_generator == StaticGenerator.GATSBY:
-            return "public"
-        elif self.static_generator == StaticGenerator.REMIX_OLD:
-            return "build/client"
-        elif self.static_generator in [
-            StaticGenerator.DOCUSAURUS,
-            StaticGenerator.DOCUSAURUS_OLD,
-            StaticGenerator.SVELTE,
-        ]:
-            return "build"
-        else:
-            return "dist"
-
     @classmethod
-    def get_build_command(cls, package_json: Optional[Dict[str, Any]], package_manager: PackageManager, static_generator: StaticGenerator) -> Optional[str]:
+    def get_build_command(
+        cls,
+        package_json: Optional[Dict[str, Any]],
+        package_manager: PackageManager,
+        static_generator: StaticGenerator,
+    ) -> Optional[str]:
         if package_json:
-            build_command = package_json.get("scripts", {}).get("build")
+            scripts = package_json.get("scripts", {})
+            generate_command = scripts.get("generate")
+            if generate_command:
+                return package_manager.run_command("generate")
+            build_command = scripts.get("build")
             if build_command:
                 return package_manager.run_command("build")
-        if static_generator == StaticGenerator.GATSBY:
-            return package_manager.run_execute_command("gatsby build")
-        elif static_generator == StaticGenerator.ASTRO:
-            return package_manager.run_execute_command("astro build")
-        elif static_generator == StaticGenerator.REMIX_OLD:
-            return package_manager.run_execute_command("remix-ssg build")
-        elif static_generator == StaticGenerator.REMIX_V2:
-            return package_manager.run_execute_command("vite build")
-        elif static_generator == StaticGenerator.DOCUSAURUS:
-            return package_manager.run_execute_command("docusaurus build")
-        elif static_generator == StaticGenerator.DOCUSAURUS_OLD:
-            return package_manager.run_execute_command("docusaurus build")
-        elif static_generator == StaticGenerator.SVELTE:
-            return package_manager.run_execute_command("svelte-kit build")
-        elif static_generator == StaticGenerator.VITE:
-            return package_manager.run_execute_command("vite build")
-        elif static_generator == StaticGenerator.NEXT:
-            return package_manager.run_execute_command("next export")
-        elif static_generator == StaticGenerator.NUXT_V3:
-            return package_manager.run_execute_command("nuxi generate")
-        elif static_generator == StaticGenerator.NUXT_OLD:
-            return package_manager.run_execute_command("nuxt generate")
-        return None
+        command = static_generator.build_command()
+        return package_manager.run_execute_command(command)
 
     def build_steps(self) -> list[str]:
-        lockfile = self.package_manager.lockfile()
+        lockfile = self.config.package_manager.lockfile()
         has_lockfile = (self.path / lockfile).exists()
-        install_command = self.package_manager.install_command(
+        install_command = self.config.package_manager.install_command(
             has_lockfile=has_lockfile
         )
-        input_files = ["package.json"]
-        # if has_lockfile:
-        #     input_files.append(lockfile)
-        inputs_install_files = ", ".join([f'"{file}"' for file in input_files])
-
         ignored_files = ["node_modules", ".git"]
         if has_lockfile:
             ignored_files.append(lockfile)
         all_ignored_files = ", ".join([f'"{file}"' for file in ignored_files])
-    
-        return [
-            'workdir(temp["build"])',
-            f'copy("{lockfile}")' if has_lockfile else None,
-            # 'run("npx corepack enable", inputs=["package.json"], group="install")',
-            f'run("{install_command}", inputs=[{inputs_install_files}], group="install")',
-            f'copy(".", ignore=[{all_ignored_files}])',
-            f'run("{self.build_command}", outputs=[shipit_static_dir], group="build")',
-            f'run("cp -R {{}}/* {{}}/".format(shipit_static_dir, app["build"]))',
-        ]
+
+        return filter(
+            None,
+            [
+                'workdir(temp.path)' if not self.only_build else None,
+                f'copy("{lockfile}")' if has_lockfile else None,
+                'env(CI="true", NODE_ENV="production", NPM_CONFIG_FUND="false")'
+                if self.config.package_manager == PackageManager.NPM
+                else None,
+                # 'run("npx corepack enable", inputs=["package.json"], group="install")',
+                f'run("{install_command}", inputs=["package.json"], group="install")',
+                f'copy(".", ignore=[{all_ignored_files}])',
+                f'run("{self.config.build_command}", outputs=[config.static_dir], group="build")'
+                if not self.only_build
+                else None,
+                f'run("{self.config.build_command}", group="build")'
+                if self.only_build
+                else None,
+                'run("cp -R {}/* {}/".format(config.static_dir, static_app.path))'
+                if not self.only_build
+                else None,
+            ],
+        )
 
     def prepare_steps(self) -> Optional[list[str]]:
         return None
 
     def mounts(self) -> list[MountSpec]:
+        if self.only_build:
+            return []
         return [MountSpec("temp", attach_to_serve=False), *super().mounts()]
 
     def volumes(self) -> list[VolumeSpec]: