forktex-cloud 2.0.0__tar.gz → 2.1.0__tar.gz

{forktex_cloud-2.0.0 → forktex_cloud-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forktex-cloud
-Version: 2.0.0
+Version: 2.1.0
 Summary: Typed Python SDK for the ForkTex Cloud platform — provision, deploy, and manage VPS-backed apps via a declarative manifest.
 License-Expression: MIT
 License-File: LICENSE

{forktex_cloud-2.0.0 → forktex_cloud-2.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "forktex-cloud"
-version = "2.0.0"
+version = "2.1.0"
 description = "Typed Python SDK for the ForkTex Cloud platform — provision, deploy, and manage VPS-backed apps via a declarative manifest."
 authors = [
     {name = "ForkTex", email = "info@forktex.com"}

{forktex_cloud-2.0.0 → forktex_cloud-2.1.0}/src/forktex_cloud/__init__.py

@@ -32,7 +32,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
-__version__ = "2.0.0"
+__version__ = "2.1.0"
 
 # ── Lazy attribute map ──────────────────────────────────────────────────────
 #

{forktex_cloud-2.0.0 → forktex_cloud-2.1.0}/src/forktex_cloud/bridge/local_compose.py

@@ -2,6 +2,13 @@
 
 Generates a simple local-oriented docker-compose.local.yml from a forktex manifest.
 No proxy, no blue-green, no SSL -- just plain containers with direct port mapping.
+
+Build-context convention: a service's ``build.context`` is interpreted relative
+to the PROJECT ROOT (a leading ``./`` is optional; ``.`` means the root). The
+generator re-bases it onto the generated compose file's directory via
+``root_prefix``. A context may not escape the project root (``..``) — each
+service builds from inside its own project. ``build.dockerfile`` is relative to
+the resolved context and must exist (both are validated at generation time).
 """
 
 from __future__ import annotations
@@ -10,6 +17,7 @@ from pathlib import Path
 from typing import Any
 
 from forktex_cloud.bridge.persistence_defaults import detect_persistence_defaults
+from forktex_cloud.manifest.errors import ManifestError
 from forktex_cloud.manifest.loader import Manifest
 from forktex_cloud.secrets.base import SecretsProvider
 
@@ -17,6 +25,76 @@ from forktex_cloud.secrets.base import SecretsProvider
 _OBSERVABILITY_PORTS = {3100}
 
 
+def _project_relative(path: str, root_prefix: str) -> str:
+    """Express a project-root-relative ``path`` relative to the compose dir.
+
+    The compose file is generated below the project root (``root_prefix`` is the
+    hop back up — e.g. ``../..`` for ``.forktex/cache/``), so a context or bind
+    source the manifest states *relative to the project root* must be re-based
+    onto it. A leading ``./`` is optional; ``.`` / ``""`` mean the root itself.
+    """
+    stripped = path.removeprefix("./")
+    if stripped in (".", ""):
+        return root_prefix
+    return f"{root_prefix}/{stripped}".rstrip("/")
+
+
+def _resolve_build_context(
+    ctx: str, *, sid: str, project_root: Path, root_prefix: str
+) -> tuple[str, Path]:
+    """Resolve a manifest build ``context`` to ``(compose-relative, on-disk dir)``.
+
+    Relative contexts are project-root-relative (leading ``./`` optional);
+    absolute contexts pass through untouched. A relative context that escapes
+    the project root (via ``..``) is rejected — every service builds from inside
+    its own project (see ``standard.forktex-architecture``); a context reaching
+    the surrounding workspace is the smell that produced the ``network/network``
+    double-path bug.
+    """
+    if ctx.startswith("/"):
+        return ctx, Path(ctx)
+    stripped = ctx.removeprefix("./")
+    on_disk = (project_root / stripped).resolve()
+    root = project_root.resolve()
+    if on_disk != root and root not in on_disk.parents:
+        raise ManifestError(
+            f"service {sid!r}: build context {ctx!r} escapes the project root "
+            f"(resolves to {on_disk}, outside {root}). Build contexts must stay "
+            f"inside the project — build the service from its own directory."
+        )
+    return _project_relative(ctx, root_prefix), on_disk
+
+
+def _require_dockerfile(ctx_dir: Path, dockerfile: str | None, *, sid: str, context: str) -> None:
+    """Fail with a clear error if the Dockerfile is missing under the context.
+
+    The ``dockerfile`` path is interpreted relative to ``context``; when the two
+    desync Docker emits only a cryptic ``lstat`` failure at build time. Surface
+    it at generation time instead.
+    """
+    rel = dockerfile or "Dockerfile"
+    target = ctx_dir / rel
+    if not target.is_file():
+        raise ManifestError(
+            f"service {sid!r}: dockerfile {rel!r} not found under build context "
+            f"{context!r} (looked for {target}). `dockerfile` is relative to "
+            f"`context`."
+        )
+
+
+def _autodetect_dockerfile(svc_dir: Path, env_name: str) -> Path | None:
+    """Find a buildable Dockerfile in ``svc_dir`` — env-specific first.
+
+    A local build wants ``Dockerfile.local`` over the prod ``Dockerfile`` when
+    both exist; fall back to the plain name otherwise.
+    """
+    for name in (f"Dockerfile.{env_name}", "Dockerfile"):
+        candidate = svc_dir / name
+        if candidate.is_file():
+            return candidate
+    return None
+
+
 def _allocate_host_ports(
     services: list[dict[str, Any]],
     *,
@@ -186,23 +264,29 @@ def local_compose_from_manifest(
         # Build context — explicit overlay first, else auto-detect a sibling
         # Dockerfile for compute services. Persistence services only opt in
         # when the manifest explicitly declares `build` (zot is the canonical
-        # case — persistence-typed but first-party).
+        # case — persistence-typed but first-party). `context` is interpreted
+        # relative to the PROJECT ROOT (leading `./` optional) and re-based onto
+        # the compose dir via root_prefix; a `dockerfile` is relative to it.
         build_cfg = svc_def.get("build")
         if build_cfg and isinstance(build_cfg, dict):
             build_entry: dict[str, str] = {}
             ctx = build_cfg.get("context", f"./{sid}")
-            # Rewrite a project-relative context to be relative to the compose
-            # file's directory (.forktex/cache/) via root_prefix.
-            build_entry["context"] = (
-                f"{root_prefix}/{ctx.removeprefix('./')}" if ctx.startswith("./") else ctx
+            compose_ctx, ctx_dir = _resolve_build_context(
+                ctx, sid=sid, project_root=project_root, root_prefix=root_prefix
             )
-            if build_cfg.get("dockerfile"):
-                build_entry["dockerfile"] = build_cfg["dockerfile"]
+            build_entry["context"] = compose_ctx
+            dockerfile = build_cfg.get("dockerfile")
+            if dockerfile:
+                build_entry["dockerfile"] = dockerfile
+            _require_dockerfile(ctx_dir, dockerfile, sid=sid, context=ctx)
             svc["build"] = build_entry
         elif svc_type == "compute":
-            dockerfile = project_root / sid / "Dockerfile"
-            if dockerfile.is_file():
-                svc["build"] = {"context": f"{root_prefix}/{sid}"}
+            found = _autodetect_dockerfile(project_root / sid, env_name)
+            if found is not None:
+                build_entry = {"context": _project_relative(f"./{sid}", root_prefix)}
+                if found.name != "Dockerfile":
+                    build_entry["dockerfile"] = found.name
+                svc["build"] = build_entry
 
         if sid in host_ports:
             host_port = host_ports[sid]
@@ -252,7 +336,7 @@ def local_compose_from_manifest(
                     src = v.split(":")[0]
                     rest = v[len(src) :]
                     if src.startswith("./"):
-                        rewritten.append(f"{root_prefix}/{src[2:]}{rest}")
+                        rewritten.append(f"{_project_relative(src, root_prefix)}{rest}")
                     elif src.startswith("/") or not src.startswith("."):
                         rewritten.append(v)
                         if not src.startswith("/"):