copydock 0.1.0__tar.gz

copydock-0.1.0/.gitignore

@@ -0,0 +1,12 @@
+.venv/
+__pycache__/
+*.egg-info/
+dist/
+build/
+.pytest_cache/
+.ruff_cache/
+
+# Never commit real settings or secrets
+.env
+*.copydock
+*.tar.gz

copydock-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dominic Quainoo Amuah
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

copydock-0.1.0/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.5
+Name: copydock
+Version: 0.1.0
+Summary: Package a Docker Compose app into a portable bundle you can install on any Linux server, online or offline.
+Project-URL: Homepage, https://github.com/Dominic62q/copydock
+Project-URL: Source, https://github.com/Dominic62q/copydock
+Project-URL: Issues, https://github.com/Dominic62q/copydock/issues
+Author: Dominic Quainoo Amuah
+License-Expression: MIT
+License-File: LICENSE
+Keywords: air-gapped,bundle,deployment,docker,docker-compose,installer,offline
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: System :: Installation/Setup
+Classifier: Topic :: System :: Software Distribution
+Requires-Python: >=3.10
+Requires-Dist: pyyaml>=6
+Requires-Dist: rich>=13
+Requires-Dist: typer>=0.12
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# CopyDock
+
+Package a Docker Compose app into one bundle, copy it to a Linux server, and install it with a
+single script. The server needs only Docker. It does not need internet, Python or CopyDock.
+
+> **Status: alpha (0.1.0).** The full flow is tested on the included sample app (frontend, API,
+> PostgreSQL, Caddy), including an install in a Docker daemon with no network. It has not yet been
+> tested on a wide range of real servers or on a real ARM server. Try it on a test machine first.
+
+## How it works
+
+```
+your laptop                       transfer                    the server
+-----------                       --------                    ----------
+copydock package ./app   ───►   USB / scp / share   ───►   tar xzf bundle.tar.gz
+  builds + collects images                                  ./install.sh
+  rewrites compose for offline                                verifies files
+  seals a checksummed bundle                                  checks Docker, CPU, disk, ports
+                                                              asks for passwords (.env, mode 600)
+                                                              loads images, starts the app
+```
+
+## Install
+
+```bash
+pipx install copydock
+```
+
+You also need Docker with the Compose plugin on the machine where you build the bundle.
+
+## Use
+
+```bash
+# 1. See what a project needs, and whether CopyDock can package it
+copydock inspect ./myapp
+
+# 2. Build a bundle for the server's CPU type (linux/amd64 or linux/arm64)
+copydock package ./myapp --app-version 1.0 --platform linux/amd64 -o dist
+
+# 3. Copy dist/myapp-1.0-linux-amd64.tar.gz to the server, then on the server:
+tar xzf myapp-1.0-linux-amd64.tar.gz
+cd myapp-1.0-linux-amd64
+./install.sh
+```
+
+`./install.sh --check` only verifies the bundle and checks the server; it changes nothing.
+
+### Commands
+
+| Command | What it does |
+| --- | --- |
+| `copydock inspect PROJECT` | Lists images, ports, required settings, and anything that blocks packaging. `--json` for scripts. |
+| `copydock package PROJECT` | Builds the bundle `.tar.gz` and a `.sha256` file. |
+
+Options for `package`: `--platform`, `--app-version`, `-f/--compose`, `-o/--output`,
+`--include-secret-files`.
+
+### On the server
+
+`./install.sh` verifies checksums, checks Docker, Compose, CPU type, disk space and ports, collects
+settings into `.env` (mode 600, never printed), loads the images from the bundle, and starts the
+app with pulling disabled. It never deletes volumes, so your data survives re-installs.
+Options: `--check`, `--non-interactive`, `--env-file PATH`.
+
+## What it deliberately does not do (yet)
+
+- It does not install Docker or Compose on the server; it checks for them.
+- It does not set up DNS or trusted HTTPS. Bundles serve plain HTTP on the server's address.
+  Caddy runs as an ordinary service in your Compose file.
+- It does not back up or migrate databases, and it does not sign bundles. Checksums catch damage,
+  not tampering: compare the `.sha256` file over a channel you trust.
+- It rejects Compose features it cannot package safely, with a clear message: external volumes or
+  networks, `secrets:`, `configs:`, `env_file`, bind mounts outside the project, variable build
+  args. Files that look like secrets (`.env`, `.pem`, `.key`) block packaging unless you pass
+  `--include-secret-files`.
+- One CPU type per bundle.
+
+External services still need internet. Packaging an app does not make an SMS provider, for
+example, work offline.
+
+## Development
+
+```bash
+uv sync --extra dev
+uv run pytest
+uv run ruff check .
+```
+
+`examples/sample-app/` is the test application. `scripts/offline-test.sh` installs a bundle in a
+Docker daemon with no network and checks the result. Scope and decisions are in `V1.md`.
+
+## License
+
+MIT. See `LICENSE`.

copydock-0.1.0/README.md

@@ -0,0 +1,94 @@
+# CopyDock
+
+Package a Docker Compose app into one bundle, copy it to a Linux server, and install it with a
+single script. The server needs only Docker. It does not need internet, Python or CopyDock.
+
+> **Status: alpha (0.1.0).** The full flow is tested on the included sample app (frontend, API,
+> PostgreSQL, Caddy), including an install in a Docker daemon with no network. It has not yet been
+> tested on a wide range of real servers or on a real ARM server. Try it on a test machine first.
+
+## How it works
+
+```
+your laptop                       transfer                    the server
+-----------                       --------                    ----------
+copydock package ./app   ───►   USB / scp / share   ───►   tar xzf bundle.tar.gz
+  builds + collects images                                  ./install.sh
+  rewrites compose for offline                                verifies files
+  seals a checksummed bundle                                  checks Docker, CPU, disk, ports
+                                                              asks for passwords (.env, mode 600)
+                                                              loads images, starts the app
+```
+
+## Install
+
+```bash
+pipx install copydock
+```
+
+You also need Docker with the Compose plugin on the machine where you build the bundle.
+
+## Use
+
+```bash
+# 1. See what a project needs, and whether CopyDock can package it
+copydock inspect ./myapp
+
+# 2. Build a bundle for the server's CPU type (linux/amd64 or linux/arm64)
+copydock package ./myapp --app-version 1.0 --platform linux/amd64 -o dist
+
+# 3. Copy dist/myapp-1.0-linux-amd64.tar.gz to the server, then on the server:
+tar xzf myapp-1.0-linux-amd64.tar.gz
+cd myapp-1.0-linux-amd64
+./install.sh
+```
+
+`./install.sh --check` only verifies the bundle and checks the server; it changes nothing.
+
+### Commands
+
+| Command | What it does |
+| --- | --- |
+| `copydock inspect PROJECT` | Lists images, ports, required settings, and anything that blocks packaging. `--json` for scripts. |
+| `copydock package PROJECT` | Builds the bundle `.tar.gz` and a `.sha256` file. |
+
+Options for `package`: `--platform`, `--app-version`, `-f/--compose`, `-o/--output`,
+`--include-secret-files`.
+
+### On the server
+
+`./install.sh` verifies checksums, checks Docker, Compose, CPU type, disk space and ports, collects
+settings into `.env` (mode 600, never printed), loads the images from the bundle, and starts the
+app with pulling disabled. It never deletes volumes, so your data survives re-installs.
+Options: `--check`, `--non-interactive`, `--env-file PATH`.
+
+## What it deliberately does not do (yet)
+
+- It does not install Docker or Compose on the server; it checks for them.
+- It does not set up DNS or trusted HTTPS. Bundles serve plain HTTP on the server's address.
+  Caddy runs as an ordinary service in your Compose file.
+- It does not back up or migrate databases, and it does not sign bundles. Checksums catch damage,
+  not tampering: compare the `.sha256` file over a channel you trust.
+- It rejects Compose features it cannot package safely, with a clear message: external volumes or
+  networks, `secrets:`, `configs:`, `env_file`, bind mounts outside the project, variable build
+  args. Files that look like secrets (`.env`, `.pem`, `.key`) block packaging unless you pass
+  `--include-secret-files`.
+- One CPU type per bundle.
+
+External services still need internet. Packaging an app does not make an SMS provider, for
+example, work offline.
+
+## Development
+
+```bash
+uv sync --extra dev
+uv run pytest
+uv run ruff check .
+```
+
+`examples/sample-app/` is the test application. `scripts/offline-test.sh` installs a bundle in a
+Docker daemon with no network and checks the result. Scope and decisions are in `V1.md`.
+
+## License
+
+MIT. See `LICENSE`.

copydock-0.1.0/pyproject.toml

@@ -0,0 +1,66 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "copydock"
+version = "0.1.0"
+description = "Package a Docker Compose app into a portable bundle you can install on any Linux server, online or offline."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Dominic Quainoo Amuah" }]
+keywords = ["docker", "docker-compose", "deployment", "offline", "air-gapped", "bundle", "installer"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Intended Audience :: System Administrators",
+    "Operating System :: MacOS",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Build Tools",
+    "Topic :: System :: Installation/Setup",
+    "Topic :: System :: Software Distribution",
+]
+dependencies = [
+    "typer>=0.12",
+    "rich>=13",
+    "pyyaml>=6",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8",
+    "ruff>=0.6",
+]
+
+[project.urls]
+Homepage = "https://github.com/Dominic62q/copydock"
+Source = "https://github.com/Dominic62q/copydock"
+Issues = "https://github.com/Dominic62q/copydock/issues"
+
+[project.scripts]
+copydock = "copydock.cli:app"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/copydock"]
+
+# Keep the source download small: code, README and license only.
+[tool.hatch.build.targets.sdist]
+include = ["src/copydock", "README.md", "LICENSE"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+# Typer's idiom is typer.Option(...) in argument defaults.
+extend-ignore = ["B008"]

copydock-0.1.0/src/copydock/__init__.py

@@ -0,0 +1,3 @@
+"""CopyDock: package a Docker Compose app into a portable deployment bundle."""
+
+__version__ = "0.1.0"

copydock-0.1.0/src/copydock/__main__.py

@@ -0,0 +1,4 @@
+from copydock.cli import app
+
+if __name__ == "__main__":
+    app()

copydock-0.1.0/src/copydock/analysis.py

@@ -0,0 +1,223 @@
+"""Read a Compose project and report what packaging it would need.
+
+`load_config` asks Docker Compose to resolve the file (profiles, extends, merges, paths).
+`analyze` is a pure function over that result, so it can be tested without Docker.
+
+Anything v1 does not support is reported as an error rather than silently skipped (see V1.md).
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import subprocess
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+
+from copydock.errors import CopyDockError
+
+COMPOSE_FILE_NAMES = ("compose.yaml", "compose.yml", "docker-compose.yaml", "docker-compose.yml")
+
+# ${VAR:?message} and ${VAR?message}: Compose refuses to run unless VAR is set.
+_REQUIRED_VAR = re.compile(r"\$\{([A-Za-z_][A-Za-z0-9_]*):?\?")
+_SECRET_FILE_HINTS = (".env", ".pem", ".key", ".p12", ".pfx")
+_UNSUPPORTED_BUILD_KEYS = {"additional_contexts", "dockerfile_inline", "secrets", "ssh"}
+
+
+@dataclass
+class Finding:
+    level: str  # "error" (v1 cannot package this) or "warning" (works, but check it)
+    message: str
+    code: str = ""  # machine-readable tag, e.g. "secret-file"
+
+
+@dataclass
+class ServiceInfo:
+    name: str
+    image: str | None
+    build_context: str | None
+    published_ports: list[int] = field(default_factory=list)
+    bind_mounts: list[str] = field(default_factory=list)  # relative to the project
+    named_volumes: list[str] = field(default_factory=list)
+
+
+@dataclass
+class Report:
+    project: str
+    compose_file: str
+    services: list[ServiceInfo] = field(default_factory=list)
+    required_env: list[str] = field(default_factory=list)
+    findings: list[Finding] = field(default_factory=list)
+
+    @property
+    def published_ports(self) -> list[int]:
+        return sorted({p for s in self.services for p in s.published_ports})
+
+    @property
+    def errors(self) -> list[Finding]:
+        return [f for f in self.findings if f.level == "error"]
+
+    @property
+    def warnings(self) -> list[Finding]:
+        return [f for f in self.findings if f.level == "warning"]
+
+    def to_dict(self) -> dict:
+        data = asdict(self)
+        data["published_ports"] = self.published_ports
+        return data
+
+
+def find_compose_file(project: Path, name: str | None) -> Path:
+    project = project.resolve()
+    if name:
+        path = project / name
+        if not path.is_file():
+            raise CopyDockError(f"Compose file not found: {path}")
+        return path
+    for candidate in COMPOSE_FILE_NAMES:
+        if (project / candidate).is_file():
+            return project / candidate
+    raise CopyDockError(
+        f"No Compose file in {project}. Looked for: {', '.join(COMPOSE_FILE_NAMES)}. "
+        "Use --compose to name it."
+    )
+
+
+def load_config(project: Path, compose_file: Path) -> dict:
+    """Resolve the Compose file with `docker compose config`.
+
+    Interpolation is left off on purpose: values like ${POSTGRES_PASSWORD} are filled in on the
+    destination server, never at package time, so inspect must not need them.
+    """
+    project = project.resolve()  # also used as cwd, so a relative path would be applied twice
+    compose_file = compose_file.resolve()
+    cmd = [
+        "docker", "compose",
+        "--project-directory", str(project),
+        "-f", str(compose_file),
+        "--profile", "*",
+        "config", "--no-interpolate", "--format", "json",
+    ]  # fmt: skip
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, cwd=project, check=False)
+    except FileNotFoundError:
+        raise CopyDockError("Docker was not found. Install Docker with the Compose plugin.") from None
+    if result.returncode != 0:
+        detail = result.stderr.strip() or "no details from docker"
+        raise CopyDockError(f"`docker compose config` failed for {compose_file.name}:\n{detail}")
+    try:
+        return json.loads(result.stdout)
+    except json.JSONDecodeError:
+        raise CopyDockError("Could not read the output of `docker compose config`.") from None
+
+
+def _inside(path: Path, root: Path) -> bool:
+    try:
+        path.resolve().relative_to(root.resolve())
+    except ValueError:
+        return False
+    return True
+
+
+def _relative(path: Path, root: Path) -> str:
+    return str(path.resolve().relative_to(root.resolve()))
+
+
+def analyze(config: dict, raw_text: str, project: Path, compose_file: str) -> Report:
+    report = Report(project=str(project), compose_file=compose_file)
+    root = project.resolve()
+    project_name = config.get("name") or root.name.lower()
+
+    # Required variables are found in the raw text: the resolved config does not list them.
+    # Limitation: variables used only in `include:`d or `extends:`d files are not seen.
+    report.required_env = sorted(set(_REQUIRED_VAR.findall(raw_text)))
+
+    for kind in ("volumes", "networks"):
+        for name, spec in (config.get(kind) or {}).items():
+            if spec and spec.get("external"):
+                report.findings.append(
+                    Finding("error", f"{kind[:-1].capitalize()} '{name}' is external. "
+                            "v1 only packages volumes and networks that Compose creates itself.")
+                )  # fmt: skip
+    for kind in ("secrets", "configs"):
+        for name in config.get(kind) or {}:
+            report.findings.append(
+                Finding("error", f"Top-level {kind[:-1]} '{name}' is not supported in v1. "
+                        "Pass the value as an environment variable instead.")
+            )  # fmt: skip
+
+    for name, svc in (config.get("services") or {}).items():
+        # A built service with no `image:` gets the name Compose would give it.
+        image = svc.get("image") or (f"{project_name}-{name}" if svc.get("build") else None)
+        info = ServiceInfo(name=name, image=image, build_context=None)
+
+        build = svc.get("build")
+        if build:
+            context = Path(build["context"] if isinstance(build, dict) else build)
+            for key in _UNSUPPORTED_BUILD_KEYS & set(build if isinstance(build, dict) else ()):
+                report.findings.append(
+                    Finding("error", f"{name}: build option '{key}' is not supported in v1.")
+                )
+            for arg, value in ((build.get("args") or {}) if isinstance(build, dict) else {}).items():
+                if value is not None and "$" in str(value):
+                    report.findings.append(
+                        Finding("error", f"{name}: build arg {arg} uses a variable. Build args "
+                                "must be fixed values, because images are built before install.")
+                    )  # fmt: skip
+            if _inside(context, root):
+                info.build_context = _relative(context, root) or "."
+            else:
+                info.build_context = str(context)
+                report.findings.append(
+                    Finding("error", f"{name}: build context {context} is outside the project.")
+                )
+
+        for port in svc.get("ports") or []:
+            published = port.get("published") if isinstance(port, dict) else None
+            if published is None:
+                continue  # container-only port, nothing opens on the host
+            try:
+                info.published_ports.append(int(published))
+            except ValueError:
+                report.findings.append(
+                    Finding("warning", f"{name}: port '{published}' is a range or uses a variable; "
+                            "it was not included in the port check.")
+                )  # fmt: skip
+
+        for vol in svc.get("volumes") or []:
+            if vol.get("type") == "volume":
+                info.named_volumes.append(vol.get("source") or "(anonymous)")
+            elif vol.get("type") == "bind":
+                source = Path(vol["source"])
+                if source.name == "docker.sock":
+                    report.findings.append(
+                        Finding("error", f"{name}: mounts the Docker socket. That gives the "
+                                "container control of the host, and v1 does not package it.")
+                    )  # fmt: skip
+                elif not _inside(source, root):
+                    report.findings.append(
+                        Finding("error", f"{name}: bind mount {source} is outside the project, "
+                                "so it cannot be bundled.")
+                    )  # fmt: skip
+                else:
+                    rel = _relative(source, root)
+                    info.bind_mounts.append(rel)
+                    if source.name.startswith(".env") or source.suffix in _SECRET_FILE_HINTS:
+                        report.findings.append(
+                            Finding("warning", f"{name}: bind mount {rel} looks like it may "
+                                    "hold secrets. Check it before bundling.", "secret-file")
+                        )  # fmt: skip
+
+        if svc.get("env_file"):
+            report.findings.append(
+                Finding("error", f"{name}: uses env_file, which is not supported in v1. Move the "
+                        "values into `environment:` as ${VARIABLES}, so the server provides them.")
+            )  # fmt: skip
+        if svc.get("privileged"):
+            report.findings.append(Finding("warning", f"{name}: runs privileged."))
+        if svc.get("network_mode") == "host":
+            report.findings.append(Finding("warning", f"{name}: uses host networking."))
+
+        report.services.append(info)
+
+    return report

copydock-0.1.0/src/copydock/cli.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import typer
+
+from copydock import __version__, ui
+from copydock.analysis import analyze, find_compose_file, load_config
+from copydock.errors import CopyDockError
+from copydock.packager import package_project
+
+app = typer.Typer(
+    help="Package a Docker Compose app into a portable bundle for any Linux server.",
+    no_args_is_help=True,
+    add_completion=False,
+    rich_markup_mode=None,
+)
+
+
+def _shorten(path: Path) -> str:
+    """Show a path relative to the current folder when it lives below it."""
+    try:
+        return str(path.relative_to(Path.cwd()))
+    except ValueError:
+        return str(path)
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        ui.console.print(f"copydock {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(
+        False, "--version", callback=_version_callback, is_eager=True, help="Show version."
+    ),
+) -> None:
+    pass
+
+
+@app.command()
+def inspect(
+    project: Path = typer.Argument(..., exists=True, file_okay=False, help="Project directory."),
+    compose: str = typer.Option(
+        None, "--compose", "-f", help="Compose file name (default: auto-detect)."
+    ),
+    as_json: bool = typer.Option(False, "--json", help="Print the report as JSON."),
+) -> None:
+    """Show what a project needs to be packaged (images, ports, variables, unsupported features)."""
+    if not as_json:
+        ui.banner(f"inspecting {project.resolve().name}")
+    try:
+        compose_path = find_compose_file(project, compose)
+        config = load_config(project, compose_path)
+        report = analyze(config, compose_path.read_text(), project, compose_path.name)
+    except CopyDockError as e:
+        ui.error("Could not inspect", str(e))
+        raise typer.Exit(1) from None
+
+    if as_json:
+        ui.console.print_json(json.dumps(report.to_dict()))
+    else:
+        ui.print_report(report)
+    if report.errors:
+        raise typer.Exit(1)
+
+
+@app.command()
+def package(
+    project: Path = typer.Argument(..., exists=True, file_okay=False, help="Project directory."),
+    compose: str = typer.Option(
+        None, "--compose", "-f", help="Compose file name (default: auto-detect)."
+    ),
+    platform: str = typer.Option(
+        None,
+        "--platform",
+        help="Platform of the SERVER: linux/amd64 or linux/arm64. "
+        "Default: the platform of this machine's Docker.",
+    ),
+    app_version: str = typer.Option("latest", "--app-version", help="Version label for the bundle."),
+    output: Path = typer.Option(Path("."), "--output", "-o", help="Folder for the bundle."),
+    include_secret_files: bool = typer.Option(
+        False,
+        "--include-secret-files",
+        help="Bundle bind-mounted files that look like secrets (.env, .pem, .key).",
+    ),
+) -> None:
+    """Build a .tar.gz bundle that installs on a Linux server, online or offline."""
+    ui.banner(f"packaging {project.resolve().name}")
+    try:
+        result = package_project(
+            project, compose, platform, output, app_version, include_secret_files
+        )
+    except CopyDockError as e:
+        ui.error("Could not package", str(e))
+        raise typer.Exit(1) from None
+
+    name = result.archive.name
+    folder = name.removesuffix(".tar.gz")
+    ui.print_bundle(
+        archive_name=name,
+        size=result.size,
+        sha256=result.sha256,
+        platform=result.manifest.platform,
+        images=result.manifest.images,
+        sidecar=result.sidecar.name,
+        next_steps=[
+            f"Copy to the server:  scp {_shorten(result.archive)} user@server:~/",
+            f"On the server:       tar xzf {name} && cd {folder} && ./install.sh",
+        ],
+    )
+    if result.findings:
+        ui.print_findings(result.findings)
+        ui.console.print()