solari-runloop-compat 0.1.0__tar.gz → 0.1.2__tar.gz

{solari_runloop_compat-0.1.0 → solari_runloop_compat-0.1.2}/BLUEPRINTS.md

@@ -42,7 +42,7 @@ pipeline) use `{op:"workdir", dir}`; `localFiles` is rejected (`LocalFilesUnsupp
    `.dockerignore` is applied client-side when the SDK uploads the directory (`storage_object.upload_from_dir`).
 Gateway work: `contextObjectId` validation (same org), the `copy` op in the build executor, ~2 days; tests for wrong-org objects.
 
-## Level 3a: any public `FROM <image>`, shipped in this PR (compat layer only, staging-verified)
+## Level 3a: any public `FROM <image>` by chroot import (SUPERSEDED by 3b for new builds; Python compat now emits `fromImage`)
 `FROM python:3.12-alpine`, `FROM node:20`, `FROM ghcr.io/org/img:tag`, and (with `build_args={"SOLARI_IMPORT": "1"}`) `FROM ubuntu`/`debian`
 **as an imported image** instead of the native base. How: the build steps (a) install `crane` (pinned `v0.20.3`, tarball sha256 checked
 at download, the binary's sha256 **re-checked before every use**, the build fails on a mismatch), (b) check the manifest size against
@@ -67,7 +67,7 @@ VM today (the builder disk size is not configurable yet, so big images fail on d
 `/etc/solari-cmd` but **not started**; public registries only; amd64 only; absolute symlinks inside the image resolve against the host in the file API,
 so reading such a path is refused (exec through `solari-run` resolves them correctly); processes from different `exec` calls share the chroot, but there is
 no PID 1/init in the image (no systemd), and a `RUN` that needs a running daemon fails.
-A warning is logged at compile time whenever import mode is used.
+The Python compat layer no longer emits these steps (it sends `compiled.fromImage`, level 3b); the exec/fs marker-file handling stays for templates built earlier.
 
 ## Level 3b: native, for every SDK (assigned to bug1; archi-sandbox's block list applies)
 guest-agent `rootDir` mode (exec chroots, fs ops use a symlink-safe join, rootDir immutable, capabilities dropped), `fromImage` on `POST /templates`

{solari_runloop_compat-0.1.0 → solari_runloop_compat-0.1.2}/COMPAT.md

@@ -29,7 +29,7 @@ gateway endpoint (see `GATEWAY-ENDPOINTS.md`); **NO** raises `SolariCompatUnsupp
 | `devbox.from_id(id)`, `devbox.list(**)` | OK, live | |
 | `Devbox.get_info / await_running / await_suspended / shutdown / suspend / resume / keep_alive` | OK, live | `suspend`/`resume` = Solari pause/resume (RAM+disk). `keep_alive` re-arms the idle window the devbox was created with (default 30 min). |
 | `with ... as devbox` (sync) / `async with` | OK | Shuts the devbox down on exit. |
-| `devbox.cmd.exec(cmd, stdout=, stderr=, output=, last_n=)` | OK, live | Runs `bash -lc "<cmd>"` from `$HOME`. Callbacks receive lines. Output is never truncated (`*_truncated` is always false). `ExecutionResult.stdout(num_lines=)` etc. as in Runloop. |
+| `devbox.cmd.exec(cmd, stdout=, stderr=, output=, last_n=)` | OK, live | Runs `bash -lc "<cmd>"` from `$HOME`; on a devbox built from an image (`FROM <image>`) it runs a non-login `bash -c` when the image has `/bin/bash` and `sh -c` when it does not (Alpine), so the image's own `PATH` survives (a login shell would reset it). As a consequence `~/.profile` and `/etc/profile.d` are not read on image devboxes. Callbacks receive lines. Output is never truncated (`*_truncated` is always false). `ExecutionResult.stdout(num_lines=)` etc. as in Runloop. |
 | `devbox.cmd.exec_async(...)` -> `Execution` | DIFF | `result()`, `get_state()`, `kill()`, `send_std_in()`, `join()` work **inside the creating process** (an in-memory registry). On a gateway with durable executions (pinetree-desktop#570, detected by probing `GET /sandboxes/{id}/executions`) every command runs through it, so `executions.retrieve / await_completed / kill / send_std_in` also work by `(devbox_id, execution_id)` from **another process**; callbacks are fed by polling the execution (~0.4 s). Against a gateway without it, the in-process registry above is used. `close_std_in` NO. |
 | `devbox.shell(name).exec / exec_async / delete`, `shell_name=` | DIFF | Wired to the gateway's named shells (pinetree-desktop#569): one persistent bash per name (cwd, env, functions, jobs persist). Output reaches `stdout=/stderr=/output=` callbacks when the command ends, not while it runs; a shell command cannot be killed or given stdin (end the shell with `shell.delete()`). Raises `SolariCompatUnsupported` on a gateway or sandbox image without shells (the guest image needs a new golden). Not yet run against staging: #569 is not deployed. |
 | `devbox.file.read / write / upload / download` | OK, live | Relative paths resolve against `$HOME`; parent dirs are created on write/upload. `upload(file=)` takes bytes, `Path`, str path or a file object. |
@@ -38,7 +38,7 @@ gateway endpoint (see `GATEWAY-ENDPOINTS.md`); **NO** raises `SolariCompatUnsupp
 | `devbox.get_tunnel()`, `get_tunnel_url(port)`, `net.enable_tunnel / get_tunnel / remove_tunnel`, create `tunnel={'auth_mode','wake_on_http','http_keep_alive'}` | DIFF, live | Real tunnel API (pinetree-desktop#575): one switch for every guest port, `https://<label>-<port>.<preview domain>`; `tunnel_key` is the `<label>`. `authenticated` (Solari's default) returns an `auth_token` that must be sent in the **`x-solari-preview-token`** header (Runloop uses `Authorization: Bearer`); `open` needs nothing. `get_tunnel()` returns `None` when no tunnel is enabled (as Runloop). **Difference:** Solari refuses `open` + `wake_on_http` (anonymous traffic could wake and bill a sandbox); the shim raises `SolariCompatUnsupported` for it, use `authenticated`. Verified on 2 gateway replicas: 40/40 requests succeed with the token, 20/20 are refused without it, revocation takes effect within 3 s. On a gateway without the tunnel API it falls back to an open per-port preview URL. |
 | `devbox.logs(execution_id=, shell_name=)` | DIFF | Uses the gateway's `GET /sandboxes/{id}/logs` when it exists (feat2's work); until then it returns the output of commands run through **this client instance** (in-process). |
 | `devbox.create_ssh_key()`, PTY tunnels, gateway/MCP tokens, `watch_evictions` | NO | Runloop platform features. |
-| `blueprint.create(name, dockerfile=, system_setup_commands=, file_mounts=, base_blueprint_name=/id=, build_args=, launch_parameters=)` | DIFF, live | Builds a Solari template from a **Dockerfile subset** and waits for it (`FROM` ubuntu/debian = the native base; **any other public image** (e.g. `python:3.12-alpine`) is imported into a chroot, see the limits below; `RUN ENV ARG WORKDIR ENTRYPOINT CMD`; `COPY`/`ADD` with a `build_context` (see below); not multi-stage, `USER`). See `BLUEPRINTS.md`. `build_context`, `code_mounts`, `services`, `secrets` NO. |
+| `blueprint.create(name, dockerfile=, system_setup_commands=, file_mounts=, base_blueprint_name=/id=, build_args=, launch_parameters=)` | DIFF, live | Builds a Solari template from a **Dockerfile subset** and waits for it (`FROM` ubuntu/debian = the native base; **any other public image** (e.g. `python:3.12-alpine`) is built natively by the gateway (`compiled.fromImage`), see the limits below; `RUN ENV ARG WORKDIR ENTRYPOINT CMD`; `COPY`/`ADD` with a `build_context` (see below); not multi-stage, `USER`). See `BLUEPRINTS.md`. `build_context`, `code_mounts`, `services`, `secrets` NO. |
 | `blueprint.from_id / list`, `Blueprint.get_info / logs / delete` | OK, live | `list()` returns your org's custom templates only. `logs()` has no timestamps/levels (Solari returns plain lines). |
 | `storage_object.upload_from_dir/bytes/text/file`, `as_build_context()`, `from_id`, `delete` | DIFF, live | Not real storage objects: the context is a deterministic `.tar.gz` **held by this client** and embedded in the build recipe, capped at ~700 KB compressed (the template body limit is 1 MiB). Honours `.dockerignore`. `COPY`/`ADD` (incl. `--chown`, `--chmod`, globs, `ADD` of a local tar) copy from it; `COPY --from`, URLs, `../` sources are refused. A context uploaded by another process is `SolariCompatUnsupported`. Everything else on `storage_object` (create, list, download, mounts) -> GATEWAY (objects). |
 | `secret.create / from_name / from_id / update / list / delete`, `Secret.get_info / update / delete`, `client.secrets.*`, create `secrets={ENV: secret_name}` | DIFF | Solari account secrets (pinetree-desktop#583): **write-only** (no route returns a value), names `[A-Za-z][A-Za-z0-9_.-]{0,63}` double as ids, values up to 16 KiB, 200 per org, at most 20 per create, reserved env names (`LD_*`, `PATH`, `HOME`...) refused. Not exercised on staging yet: the gateway answers 501 until the org-secrets key exists, and the shim then raises `SolariCompatUnsupported`. |
@@ -86,16 +86,22 @@ figures are not forwarded). No size at all leaves Solari's defaults (2 vCPU / 2
 | `XX_LARGE` | 8 vCPU, 32 GiB | 8 vCPU, **16 GiB (capped)** |
 | `CUSTOM_SIZE` | `custom_cpu_cores`, `custom_gb_memory` | ceil(cpu) capped at 8; memory x 1024 MiB capped at 16384 |
 
-### Image import limits (`FROM <image>`, BLUEPRINTS.md level 3a)
-The image needs a `/bin/sh` (distroless fails the build); about 2 GB of free disk in the builder; `ENTRYPOINT`/`CMD` are recorded, **not started**;
-public registries from an allowlist only, amd64 only, no credentials; the root is a chroot in your own microVM (not a security boundary); no init/systemd
-inside the image; absolute symlinks inside the image are refused by the file API (use `cmd.exec`). A warning is logged whenever import mode is used.
+### `FROM <image>` limits (native image build, BLUEPRINTS.md level 3b)
+The gateway pulls the image (public registries from an allowlist only, amd64 only, no credentials), unpacks it, and runs `RUN` steps and `cmd.exec`
+inside it; the root is a chroot in your own microVM (not a security boundary); no init/systemd inside the image. The image needs a shell for `RUN`.
+Needs a gateway with native image builds (`POST /templates` accepting `compiled.fromImage`); until then the build fails instead of silently building a plain base.
+
+**The image's own `ENV` is carried over**: `PATH`, `GOPATH`, `JAVA_HOME` and the like come from the image config, so `FROM golang:1.22` has `go` on `PATH`.
+`ENV` values may refer to them (`ENV PATH=/opt/x/bin:$PATH` keeps the image's `/go/bin:/usr/local/go/bin`); the gateway expands `$NAME` against the
+image's env and earlier `ENV` lines when it builds. `ARG` values are expanded by the client. Images from before this change (built with the old chroot
+import) keep working but still lack the image's `ENV`: rebuild them.
 
 ## Status, errors, pagination
 - Status (Solari state -> `DevboxView.status`): `starting`->`initializing`, `running`->`running`, `paused`->`suspended`,
-  `archived`->`suspended`, `releasing`->`shutdown`, `gone`->`shutdown`; anything else `failure`.
+  `archived`->`suspended`, `stopped`->`shutdown`, `releasing`->`shutdown`, `gone`->`shutdown`; anything else `failure`.
   `DevboxView` fields Solari does not have are synthesized: `create_time_ms` from `createdAt`, one `state_transitions`
   entry, `launch_parameters` from the real `cpu`/`memMb`, `capabilities=[]`.
+- Solari's `stopped` state (guest powered itself off; `POST /sandboxes/:id/start`) has no Runloop equivalent: there is no `Devbox.start`, and a `stopped` sandbox reports status `shutdown` (same as the TypeScript package). Use `solari_sandbox`'s `start()` directly.
 - Errors: 400 `BadRequestError`, 401 `AuthenticationError`, 402 and 403 `PermissionDeniedError` (`status_code` keeps 402),
   404 `NotFoundError`, 409 `ConflictError`, 422 `UnprocessableEntityError`, 429 `RateLimitError`, 5xx `InternalServerError`;
   network -> `APIConnectionError`, timeouts -> `APITimeoutError`. `.body` is Solari's `{code,error,message,retryable}`.

{solari_runloop_compat-0.1.0 → solari_runloop_compat-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: solari-runloop-compat
-Version: 0.1.0
+Version: 0.1.2
 Summary: Runloop-compatible Python interface over Solari Sandboxes. Not affiliated with Runloop.
 Project-URL: Homepage, https://getsolari.com
 Author: Solari
@@ -9,8 +9,8 @@ License-File: NOTICE
 Keywords: compatibility,runloop,sandbox,solari
 Requires-Python: >=3.9
 Requires-Dist: pydantic<3,>=2
-Requires-Dist: solari-core>=0.3.1
-Requires-Dist: solari-sandbox>=0.2.4
+Requires-Dist: solari-core>=0.4.0
+Requires-Dist: solari-sandbox>=0.3.0
 Provides-Extra: test
 Requires-Dist: pytest-asyncio>=0.23; extra == 'test'
 Requires-Dist: pytest>=7; extra == 'test'

{solari_runloop_compat-0.1.0 → solari_runloop_compat-0.1.2}/pyproject.toml

@@ -4,14 +4,14 @@ build-backend = "hatchling.build"
 
 [project]
 name = "solari-runloop-compat"
-version = "0.1.0"
+version = "0.1.2"
 description = "Runloop-compatible Python interface over Solari Sandboxes. Not affiliated with Runloop."
 readme = "README.md"
 requires-python = ">=3.9"
 license = { text = "MIT" }
 authors = [{ name = "Solari" }]
 keywords = ["solari", "sandbox", "runloop", "compatibility"]
-dependencies = ["solari-sandbox>=0.2.4", "solari-core>=0.3.1", "pydantic>=2,<3"]
+dependencies = ["solari-sandbox>=0.3.0", "solari-core>=0.4.0", "pydantic>=2,<3"]
 
 [project.optional-dependencies]
 test = ["pytest>=7", "pytest-asyncio>=0.23"]

{solari_runloop_compat-0.1.0 → solari_runloop_compat-0.1.2}/solari_runloop/__init__.py

@@ -29,7 +29,7 @@ from ._exceptions import (
 from .lib.polling import PollingConfig, PollingTimeout
 from .sdk import AsyncRunloopSDK, RunloopSDK
 
-__version__ = "0.1.0"
+__version__ = "0.1.2"
 Client = Runloop
 AsyncClient = AsyncRunloop
 

{solari_runloop_compat-0.1.0 → solari_runloop_compat-0.1.2}/solari_runloop/_dockerfile.py

@@ -5,7 +5,8 @@ result, so a Dockerfile maps onto that recipe rather than onto an OCI image buil
 that model can do faithfully; everything else raises :class:`SolariCompatUnsupported` naming the instruction
 (BLUEPRINTS.md describes the full design and the path to arbitrary base images).
 
-Supported: ``FROM`` (one stage; ubuntu/debian-family or a Solari base/template), ``RUN``, ``ENV``, ``ARG`` (defaults and
+Supported: ``FROM`` (one stage; ubuntu/debian-family or a Solari base/template map to the native base, any other public
+image becomes the gateway's native ``compiled.fromImage`` build, BLUEPRINTS.md level 3b), ``RUN``, ``ENV``, ``ARG`` (defaults and
 ``--build-arg``), ``WORKDIR``, ``ENTRYPOINT``, ``CMD``, ``LABEL``/``EXPOSE``/``MAINTAINER`` (ignored), ``SHELL`` (bash only).
 Not yet: ``COPY``/``ADD`` (need build-context objects), multi-stage, ``USER``, ``VOLUME``, ``HEALTHCHECK``, ``ONBUILD``.
 """
@@ -18,7 +19,6 @@ import posixpath
 import re
 import logging
 import shlex
-from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
 from . import _exceptions as ex
@@ -30,30 +30,12 @@ DEBIAN_FAMILY = {"ubuntu", "debian"}
 #: Names that select a Solari golden base directly.
 SOLARI_BASES = {"base", "workstation"}
 
-#: Pinned build tool for image import (BLUEPRINTS.md, level 3a). The build FAILS if the checksum does not match.
-CRANE_VERSION = "v0.20.3"
-CRANE_SHA256 = "36c67a932f489b3f2724b64af90b599a8ef2aa7b004872597373c0ad694dc059"
-CRANE_URL = f"https://github.com/google/go-containerregistry/releases/download/{CRANE_VERSION}/go-containerregistry_Linux_x86_64.tar.gz"
-ROOT_DIR = "/srv/root"
 CONTEXT_DIR = "/tmp/solari-context"
 #: Registries the import accepts (public pulls only; there are no credentials in the build).
 REGISTRY_ALLOWLIST = ("docker.io", "index.docker.io", "registry-1.docker.io", "ghcr.io", "public.ecr.aws", "gcr.io", "quay.io", "mcr.microsoft.com")
 #: ``build_args`` switch that forces image import even for ubuntu/debian images (default: those use the native base).
 IMPORT_ARG = "SOLARI_IMPORT"
 
-_GUEST = Path(__file__).parent / "_guest"
-#: Runs a command inside the imported root (ENV and WORKDIR applied); installed into the builder, so into every
-#: devbox created from the template. The compat layer's exec wrapper calls it too.
-SOLARI_RUN = (_GUEST / "solari-run.sh").read_text()
-#: Validating tar extractor (see its docstring for the guards).
-SOLARI_EXTRACT = (_GUEST / "solari_extract.py").read_text()
-SOLARI_SIZECHECK = (_GUEST / "solari_sizecheck.py").read_text()
-#: Caps for one import: compressed layers (checked from the manifest before downloading), extracted bytes, wall clock.
-MAX_COMPRESSED_BYTES = 2 << 30
-MAX_EXTRACTED_BYTES = 4 << 30
-IMPORT_TIMEOUT_S = 900
-CRANE_BIN_SHA256 = "675f3b2f1696c1f6bc55b1ef535163364119776999f3d1471e4558ed35bab548"
-
 
 def logical_lines(text: str) -> List[Tuple[str, str]]:
     """Join ``\\`` continuations, drop comments/blank lines, split into ``(INSTRUCTION, rest)``."""
@@ -84,9 +66,14 @@ def logical_lines(text: str) -> List[Tuple[str, str]]:
 DEFAULT_PATH = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
 
 
-def _subst(s: str, args: Dict[str, str]) -> str:
+def _subst(s: str, args: Dict[str, str], only: Optional[set] = None) -> str:
+    """Expand ``$NAME`` / ``${NAME}``. With ``only``, names outside it stay literal (the gateway expands them against the
+    image's own config env when it builds an ``ENV`` step)."""
+
     def rep(m: "re.Match[str]") -> str:
         name = m.group(1) or m.group(2)
+        if only is not None and name not in only:
+            return m.group(0)
         return args.get(name, "")
 
     return re.sub(r"\$(?:\{([A-Za-z_][A-Za-z0-9_]*)\}|([A-Za-z_][A-Za-z0-9_]*))", rep, s)
@@ -118,7 +105,7 @@ def _registry_of(image: str) -> str:
 
 
 def _resolve_from(rest: str, args: Dict[str, str]) -> Tuple[Optional[str], Optional[str], Optional[str]]:
-    """-> ``(base, from_template, import_image)`` for the CompiledImage."""
+    """-> ``(base, from_template, from_image)`` for the CompiledImage."""
     tokens = [t for t in rest.split() if not t.startswith("--")]
     if "AS" in [t.upper() for t in tokens[1:]]:
         raise ex.SolariCompatUnsupported("Multi-stage Dockerfile (FROM ... AS)", "Single-stage builds only.")
@@ -143,7 +130,7 @@ def _resolve_from(rest: str, args: Dict[str, str]) -> Tuple[Optional[str], Optio
     if registry not in REGISTRY_ALLOWLIST:
         raise ex.SolariCompatUnsupported(
             f"FROM {image}",
-            f"Image import only pulls public images from {', '.join(REGISTRY_ALLOWLIST)} (no registry credentials in builds).",
+            f"FROM <image> only builds public images from {', '.join(REGISTRY_ALLOWLIST)} (no registry credentials in builds).",
         )
     return None, None, image
 
@@ -166,7 +153,8 @@ def compile_dockerfile(
     args: Dict[str, str] = {"PATH": DEFAULT_PATH, **(build_args or {})}  # ARG + ENV, for $VAR substitution
     arg_only: Dict[str, str] = dict(build_args or {})  # ARGs, exported into each RUN
     seen_from = False
-    import_image: Optional[str] = None
+    from_image: Optional[str] = None
+    arg_names: set = set(build_args or {})  # ARG / --build-arg names: expanded here; ENV names are expanded by the gateway
     workdir = "/"
     context_loaded = False
 
@@ -179,47 +167,39 @@ def compile_dockerfile(
             if base_blueprint_name:
                 log.warning("base_blueprint_name %r overrides the Dockerfile FROM", base_blueprint_name)
             else:
-                base, from_template, import_image = fb, ft, img
-                if import_image:
-                    log.warning(
-                        "FROM %s is imported into a chroot inside the builder VM (BLUEPRINTS.md level 3a): needs a shell in the image, "
-                        "~2 GB free disk, ENTRYPOINT/CMD are recorded but not started, public registries only.",
-                        import_image,
-                    )
-                    steps.extend(import_steps(import_image))
+                base, from_template, from_image = fb, ft, img
+                if from_image:
+                    # Native image build (level 3b): RUN steps and exec run inside the unpacked image, and the gateway
+                    # expands ENV values against the image's own config env, so the seed PATH is not a Dockerfile variable.
+                    if "PATH" not in (build_args or {}):
+                        args.pop("PATH", None)
         elif instr == "ARG":
             k, eq, v = rest.partition("=")
             k = k.strip()
             args.setdefault(k, v.strip().strip('"') if eq else "")
             arg_only[k] = args[k]
+            arg_names.add(k)
         elif instr == "ENV":
-            for k, v in _parse_env(_subst(rest, args)):
+            for k, v in _parse_env(_subst(rest, args, arg_names) if from_image else _subst(rest, args)):
                 if not re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*", k):
                     raise ex.SolariCompatUnsupported(f"ENV name {k!r}", "Environment variable names must match [A-Za-z_][A-Za-z0-9_]*.")
                 args[k] = v
+                arg_names.discard(k)
                 steps.append({"op": "env", "key": k, "value": v})
-                if import_image:
-                    steps.append(_run(f"printf 'export %s=%s\\n' {shlex.quote(k)} {shlex.quote(shlex.quote(v))} >> /etc/solari-env"))
         elif instr == "RUN":
             cmd = " ".join(shlex.quote(a) for a in json.loads(rest)) if rest.startswith("[") else _subst_run(rest, arg_only)
-            steps.append(_run("solari-run " + shlex.quote(cmd)) if import_image else _run(cmd))
+            steps.append(_run(cmd))
         elif instr == "WORKDIR":
             wd = _subst(rest, args)
             wd = wd if wd.startswith("/") else posixpath.normpath(posixpath.join(workdir, wd))
             workdir = wd
             steps.append({"op": "workdir", "dir": wd})
-            if import_image:
-                steps.append(_run(f"echo {shlex.quote(wd)} > /etc/solari-workdir && solari-run {shlex.quote('mkdir -p ' + shlex.quote(wd))}"))
         elif instr == "ENTRYPOINT":
             cmdv = _json_or_shell(_subst(rest, args))
             steps.append({"op": "entrypoint", "command": cmdv})
-            if import_image:
-                steps.append(_run(f"echo {shlex.quote(json.dumps(cmdv))} > /etc/solari-entrypoint"))
         elif instr == "CMD":
             cmdv = _json_or_shell(_subst(rest, args))
             steps.append({"op": "cmd", "command": cmdv})
-            if import_image:
-                steps.append(_run(f"echo {shlex.quote(json.dumps(cmdv))} > /etc/solari-cmd"))
         elif instr in ("LABEL", "EXPOSE", "MAINTAINER", "STOPSIGNAL"):
             continue
         elif instr == "SHELL":
@@ -231,15 +211,15 @@ def compile_dockerfile(
             if not context_loaded:
                 steps.append(_context_step(context))
                 context_loaded = True
-            steps.append(_copy_step(instr, _subst(rest, args), workdir, bool(import_image)))
+            steps.append(_copy_step(instr, _subst(rest, args), workdir))
         else:
             raise ex.SolariCompatUnsupported(instr)
 
     for cmd in system_setup_commands or []:
-        steps.append(_run("solari-run " + shlex.quote(cmd)) if import_image else _run(cmd))
+        steps.append(_run(cmd))
     for path, contents in (file_mounts or {}).items():
         b64 = base64.b64encode(contents.encode()).decode()
-        dest = (ROOT_DIR + posixpath.normpath(path)) if import_image else path
+        dest = path
         steps.append(_run(f"mkdir -p \"$(dirname {shlex.quote(dest)})\" && echo {b64} | base64 -d > {shlex.quote(dest)}"))
     if not seen_from and not from_template:
         base = "base"
@@ -248,6 +228,8 @@ def compile_dockerfile(
     out: Dict[str, Any] = {"kind": "sandbox", "packages": [], "steps": steps, "fragment": "", "localFiles": []}
     if from_template:
         out["fromTemplate"] = from_template
+    elif from_image:
+        out["fromImage"] = from_image
     else:
         out["base"] = base or "base"
     return out
@@ -265,40 +247,6 @@ def _run(command: str) -> Dict[str, Any]:
     return {"op": "run", "command": command}
 
 
-def import_steps(image: str) -> List[Dict[str, Any]]:
-    """Build steps that pull ``image`` into ``/srv/root`` and install the ``solari-run`` wrapper."""
-    b64 = lambda text: base64.b64encode(text.encode()).decode()  # noqa: E731
-    img = shlex.quote(image)
-    crane_ok = f"echo '{CRANE_BIN_SHA256}  /usr/local/bin/crane' | sha256sum -c - >/dev/null || {{ echo 'solari: crane binary checksum mismatch' >&2; exit 1; }}"
-    size_check = f"python3 /usr/local/bin/solari-size-check \"$SOLARI_IMAGE\" {MAX_COMPRESSED_BYTES}"
-    return [
-        _run(
-            "set -e; mkdir -p /usr/local/bin; if [ ! -x /usr/local/bin/crane ]; then curl -fsSL " + shlex.quote(CRANE_URL) + " -o /tmp/crane.tgz && "
-            f"echo '{CRANE_SHA256}  /tmp/crane.tgz' | sha256sum -c - && tar -xzf /tmp/crane.tgz -C /usr/local/bin crane && rm -f /tmp/crane.tgz; fi; " + crane_ok
-        ),
-        _run(
-            f"echo {b64(SOLARI_EXTRACT)} | base64 -d > /usr/local/bin/solari-extract && echo {b64(SOLARI_SIZECHECK)} | base64 -d > /usr/local/bin/solari-size-check && "
-            "chmod 0755 /usr/local/bin/solari-extract /usr/local/bin/solari-size-check"
-        ),
-        # Build steps run under plain sh, so the pipeline (which needs pipefail) runs in an explicit bash.
-        _run(
-            "bash -c "
-            + shlex.quote(
-                "set -eo pipefail; " + crane_ok + f"; export DOCKER_CONFIG=$(mktemp -d) SOLARI_IMAGE={img}; "
-                + size_check
-                + f"; rm -rf {ROOT_DIR}; mkdir -p {ROOT_DIR}; "
-                f"timeout {IMPORT_TIMEOUT_S} crane export --platform linux/amd64 {img} - | python3 /usr/local/bin/solari-extract {ROOT_DIR} {MAX_EXTRACTED_BYTES}; "
-                'rm -rf "$DOCKER_CONFIG"; '
-                f"chroot {ROOT_DIR} /bin/sh -c true 2>/dev/null || {{ echo {shlex.quote('solari: image ' + image + ' has no /bin/sh; image import needs a shell (distroless images are not supported)')} >&2; exit 1; }}"
-            )
-        ),
-        _run(
-            f"echo {b64(SOLARI_RUN)} | base64 -d > /usr/local/bin/solari-run && chmod 0755 /usr/local/bin/solari-run && "
-            f"echo {ROOT_DIR} > /etc/solari-rootdir && : > /etc/solari-env && echo / > /etc/solari-workdir"
-        ),
-    ]
-
-
 _GLOB_SAFE = re.compile(r"[A-Za-z0-9_./*?\[\]+@%-]+")
 
 
@@ -306,8 +254,8 @@ def _context_step(context: bytes) -> Dict[str, Any]:
     return _run(f"rm -rf {CONTEXT_DIR} && mkdir -p {CONTEXT_DIR} && echo {base64.b64encode(context).decode()} | base64 -d | tar -xz -C {CONTEXT_DIR}")
 
 
-def _copy_step(instr: str, rest: str, workdir: str, imported: bool) -> Dict[str, Any]:
-    """``COPY``/``ADD`` from the extracted build context into the image (or, for an import, into the image root)."""
+def _copy_step(instr: str, rest: str, workdir: str) -> Dict[str, Any]:
+    """``COPY``/``ADD`` from the extracted build context into the image."""
     parts = shlex.split(rest) if not rest.startswith("[") else json.loads(rest)
     flags = [p for p in parts if p.startswith("--")]
     parts = [p for p in parts if not p.startswith("--")]
@@ -327,7 +275,7 @@ def _copy_step(instr: str, rest: str, workdir: str, imported: bool) -> Dict[str,
     abs_dest = posixpath.normpath(dest if dest.startswith("/") else posixpath.join(workdir, dest))
     if dest.endswith("/") or dest in (".", "./"):
         abs_dest = abs_dest.rstrip("/") + "/"
-    real_dest = (ROOT_DIR + abs_dest) if imported else abs_dest
+    real_dest = abs_dest
     quoted = " ".join(s if _GLOB_SAFE.fullmatch(s) else shlex.quote(s) for s in srcs)
     into_dir = dest.endswith("/") or len(srcs) > 1
     q_dest = shlex.quote(real_dest)

{solari_runloop_compat-0.1.0 → solari_runloop_compat-0.1.2}/solari_runloop/_gateway.py

@@ -117,6 +117,7 @@ class Gateway:
         self._starting_after: Optional[bool] = None
         self._objects: Optional[bool] = None  # gateway has /objects (#574)
         self._native: set = set()  # devboxes whose guest agent chroots into an imported image itself
+        self._plain: set = set()  # devboxes known NOT to be a native image build
         self._tunnel_api: Optional[bool] = None  # gateway has /sandboxes/{id}/tunnel (#575)
         self._durable: Optional[bool] = None  # gateway has /sandboxes/{id}/executions (pinetree-desktop#570)
         self._remote: Dict[str, str] = {}  # execution id -> devbox id, for executions started through the durable API
@@ -325,22 +326,31 @@ class Gateway:
                 raise mp.map_error(e) from e
         raise mp.map_error(last) from last  # type: ignore[arg-type]
 
+    async def _is_native(self, devbox_id: str) -> bool:
+        """3b: the guest agent chroots natively, so exec/fs can't see the host markers. The gateway says so on the sandbox view
+        (`fromImage` / `rootDir`): then no wrapper, no path prefix, no cwd from us, and no bash (an Alpine image has none) or
+        login shell (it would reset the image's PATH)."""
+        if devbox_id in self._native:
+            return True
+        # One GET per new devbox id; `_plain` caches the negative so exec does not pay it again. Keep it.
+        if devbox_id not in self._plain:
+            view = await self.get_raw(devbox_id)
+            if view.get("fromImage") or view.get("rootDir"):
+                self._native.add(devbox_id)
+                return True
+            self._plain.add(devbox_id)
+        return False
+
     async def _env(self, devbox_id: str) -> Tuple[str, Optional[str], str]:
         """``(home, image_root, workdir)``: ``image_root`` is set for devboxes made from an image-import blueprint."""
         if devbox_id not in self._home:
-            r = await self._on_channel(
-                devbox_id,
-                lambda h: h.commands.run("/bin/bash", args=["-lc", 'printf "%s\\n%s\\n%s\\n%s\\n" "$HOME" "$(cat /etc/solari-rootdir 2>/dev/null)" "$(cat /etc/solari-workdir 2>/dev/null)" ""']),
-            )
+            native = await self._is_native(devbox_id)
+            probe = 'printf "%s\\n%s\\n%s\\n%s\\n" "$HOME" "$(cat /etc/solari-rootdir 2>/dev/null)" "$(cat /etc/solari-workdir 2>/dev/null)" ""'
+            pcmd, pargs = mp.shell_wrap(probe, native=native)
+            r = await self._on_channel(devbox_id, lambda h: h.commands.run(pcmd, args=pargs))
             lines = (r.stdout.split("\n") + ["", "", "", ""])[:4]
             home = lines[0].strip() or "/root"
-            # 3b: the guest agent chroots natively, so exec/fs can't see the host markers. The gateway says so on the
-            # sandbox view (`fromImage` / `rootDir`): then no wrapper, no path prefix, no cwd from us.
-            view = await self.get_raw(devbox_id)
-            native = bool(view.get("fromImage") or view.get("rootDir"))
             root = None if native else (lines[1].strip() or None)
-            if native:
-                self._native.add(devbox_id)
             # Some guest images name a $HOME that does not exist yet.
             await self._on_channel(devbox_id, lambda h: h.commands.run("/bin/mkdir", args=["-p", home]))
             self._home[devbox_id] = (home, root, lines[2].strip() or "/")
@@ -388,7 +398,7 @@ class Gateway:
             asyncio.get_running_loop().create_task(self._remote_watch(rec))
             return rec
         home, root, _wd = await self._env(devbox_id)  # Runloop runs commands from the user's home directory.
-        cmd, args = mp.shell_wrap(f"solari-run {shlex.quote(command)}" if root else command)
+        cmd, args = mp.shell_wrap(f"solari-run {shlex.quote(command)}" if root else command, native=devbox_id in self._native)
         cwd = None if devbox_id in self._native else home
         ch = await self._on_channel(devbox_id, lambda h: h.commands.start(cmd, args=args, cwd=cwd))
         rec = _Exec(execution_id=f"exec_{uuid.uuid4().hex}", devbox_id=devbox_id, command=command, handle=ch, callbacks=(stdout, stderr, output))
@@ -435,7 +445,8 @@ class Gateway:
         )
 
     async def remote_start(self, devbox_id: str, command: str, callbacks: Tuple[Optional[LogCallback], Optional[LogCallback], Optional[LogCallback]]) -> DevboxAsyncExecutionDetailView:
-        body = {"cmd": "/bin/bash", "args": ["-lc", self._remote_script()], "env": {"SOLARI_USER_CMD": command}}
+        cmd, args = mp.shell_wrap(self._remote_script(), native=await self._is_native(devbox_id))
+        body = {"cmd": cmd, "args": args, "env": {"SOLARI_USER_CMD": command}}
         d = await self._req("POST", f"/sandboxes/{_q(devbox_id)}/executions", body, idempotency_key=new_idempotency_key())
         self._remote[d["executionId"]] = devbox_id
         if any(callbacks):
@@ -786,6 +797,13 @@ class Gateway:
         if mem_mb:
             body["memMb"] = mem_mb
         d = await self._req("POST", "/templates", body, idempotency_key=new_idempotency_key())
+        if compiled.get("fromImage") and not d.get("fromImage"):
+            # A gateway that predates native image builds ignores `fromImage` and would build a plain base template.
+            try:
+                await self.blueprint_delete(d["templateId"])
+            except Exception:  # noqa: BLE001 - best effort: the build row is useless either way
+                log.warning("could not discard template %s after refusing a gateway without native image builds", d.get("templateId"))
+            raise ex.SolariCompatUnsupported("FROM <image>", "This gateway has no native image builds (compiled.fromImage) yet.")
         return mp.to_blueprint_view(d)
 
     async def blueprint_get(self, blueprint_id: str) -> BlueprintView:

{solari_runloop_compat-0.1.0 → solari_runloop_compat-0.1.2}/solari_runloop/_mapping.py

@@ -73,6 +73,8 @@ STATUS_MAP: Dict[str, str] = {
     "running": "running",
     "paused": "suspended",
     "archived": "suspended",
+    # Guest powered itself off; only Solari's start() can boot it again and Runloop has no such verb, so it reads as ended.
+    "stopped": "shutdown",
     "releasing": "shutdown",
     "gone": "shutdown",
 }
@@ -287,8 +289,19 @@ def translate_errors() -> Iterator[None]:
 # --- exec -----------------------------------------------------------------------------------
 
 
-def shell_wrap(command: str) -> Tuple[str, List[str]]:
-    """Runloop takes a shell string; Solari exec is argv with no shell."""
+#: Native image devboxes: a NON-login bash when the image has one (Runloop semantics: `[[ ]]`, arrays, `{a,b}`, pipefail), else sh
+#: (Alpine, busybox). The command is passed as "$1" so it is never re-parsed by the wrapper.
+NATIVE_SHELL_SCRIPT = 'if [ -x /bin/bash ]; then exec /bin/bash -c "$1"; else exec /bin/sh -c "$1"; fi'
+
+
+def shell_wrap(command: str, *, native: bool = False) -> Tuple[str, List[str]]:
+    """Runloop takes a shell string; Solari exec is argv with no shell.
+
+    A devbox built from an image (``fromImage``) runs in that image: a login shell would re-source its /etc/profile, which
+    on Debian-family images resets ``PATH`` and drops the image's own (``/go/bin`` ...). Those get a plain (non-login) bash
+    when the image has one and ``sh -c`` otherwise (Alpine has no bash), with the environment the guest agent already applied."""
+    if native:
+        return "/bin/sh", ["-c", NATIVE_SHELL_SCRIPT, "sh", command]
     return "/bin/bash", ["-lc", command]
 
 

{solari_runloop_compat-0.1.0 → solari_runloop_compat-0.1.2}/tests/test_context.py

@@ -60,9 +60,11 @@ def test_copy_steps(tmp_path):
     assert "app/main.py" in names(base64.b64decode(blob))
 
 
-def test_copy_into_an_imported_root(tmp_path):
+def test_copy_into_a_from_image_build(tmp_path):
     c = compile_with(tmp_path, "FROM python:3.12-alpine\nCOPY README.md /srv/R.md")
-    assert any("/srv/root/srv/R.md" in s.get("command", "") for s in c["steps"])
+    assert c["fromImage"] == "python:3.12-alpine"
+    assert any("cp -a -- README.md /srv/R.md" in s.get("command", "").replace("'", "") for s in c["steps"])
+    assert not any("/srv/root" in s.get("command", "") for s in c["steps"])
 
 
 def test_add_unpacks_a_local_archive(tmp_path):

{solari_runloop_compat-0.1.0 → solari_runloop_compat-0.1.2}/tests/test_dockerfile.py

@@ -68,31 +68,51 @@ def test_logical_lines_joins_continuations_and_skips_comments():
     assert df.logical_lines("RUN a \\\n  # note\n  b\n\n# c\nENV x=1") == [("RUN", "a    b"), ("ENV", "x=1")]
 
 
-def test_import_mode_for_other_images():
+def test_other_images_use_the_native_from_image_build():
     c = df.compile_dockerfile("FROM python:3.12-alpine\nENV A=1\nWORKDIR /app\nRUN pip --version\nENTRYPOINT [\"/e\"]")
-    cmds = [s["command"] for s in c["steps"] if s["op"] == "run"]
-    assert c["base"] == "base"
-    assert "crane export --platform linux/amd64 python:3.12-alpine -" in cmds[2]
-    assert cmds[-1].startswith("echo /app > /etc/solari-workdir") is False
-    assert any(x.startswith("solari-run 'pip --version'") for x in cmds)
-    assert any("/etc/solari-env" in x and "A" in x for x in cmds)
-
-
-def test_crane_is_pinned_and_checked_at_use():
-    steps = [s["command"] for s in df.import_steps("python:3.12")]
-    assert df.CRANE_SHA256 in steps[0] and "sha256sum -c" in steps[0]
-    assert df.CRANE_BIN_SHA256 in steps[2]  # the binary is re-verified before every export
-    assert df.CRANE_VERSION in df.CRANE_URL
-    assert "solari-extract" in steps[2] and f"timeout {df.IMPORT_TIMEOUT_S}" in steps[2]
-    assert "DOCKER_CONFIG=$(mktemp -d)" in steps[2]  # no ambient registry credentials
-    assert "solari-size-check" in steps[2] and str(df.MAX_COMPRESSED_BYTES) in steps[2] and "has no /bin/sh" in steps[2]
-    assert steps[2].startswith("bash -c ") and "pipefail" in steps[2]
-    assert "\nPY" not in steps[2]  # no heredocs: the build runs each step as one command
+    assert c["fromImage"] == "python:3.12-alpine" and "base" not in c and "fromTemplate" not in c
+    assert c["steps"] == [
+        {"op": "env", "key": "A", "value": "1"},
+        {"op": "workdir", "dir": "/app"},
+        {"op": "run", "command": "pip --version"},
+        {"op": "entrypoint", "command": ["/e"]},
+    ]
+    blob = repr(c)
+    assert "crane" not in blob and "solari-run" not in blob and "/srv/root" not in blob  # no chroot shim any more
+
+
+def test_from_image_env_keeps_the_images_own_variables_for_the_gateway():
+    # golang:1.22 has PATH=/go/bin:/usr/local/go/bin:...; the gateway expands $PATH against it, so it must not be pre-expanded here.
+    c = df.compile_dockerfile("FROM golang:1.22\nENV PATH=/opt/x/bin:$PATH\nENV GOFLAGS=-mod=mod:${PATH}")
+    assert c["fromImage"] == "golang:1.22"
+    assert c["steps"][0] == {"op": "env", "key": "PATH", "value": "/opt/x/bin:$PATH"}
+    assert c["steps"][1] == {"op": "env", "key": "GOFLAGS", "value": "-mod=mod:${PATH}"}
+
+
+def test_from_image_env_chain_is_left_to_the_gateway_and_args_are_expanded_here():
+    c = df.compile_dockerfile("FROM node:20\nARG V=7\nENV A=/opt/$V\nENV PATH=$A/bin:$PATH")
+    assert [(s["key"], s["value"]) for s in c["steps"]] == [("A", "/opt/7"), ("PATH", "$A/bin:$PATH")]
+
+
+def test_from_image_build_arg_path_is_a_real_argument():
+    c = df.compile_dockerfile("FROM node:20\nENV X=$PATH", build_args={"PATH": "/custom"})
+    assert c["steps"][0]["value"] == "/custom"
+
+
+def test_from_image_build_arg_path_combined_with_an_env_that_references_it():
+    c = df.compile_dockerfile("FROM node:20\nENV PATH=/opt/x/bin:$PATH", build_args={"PATH": "/custom"})
+    assert c["steps"][0] == {"op": "env", "key": "PATH", "value": "/opt/x/bin:/custom"}
+
+
+def test_native_base_images_still_expand_path_against_dockers_default():
+    c = df.compile_dockerfile("FROM ubuntu:22.04\nENV PATH=/opt/x/bin:$PATH")
+    assert "fromImage" not in c and c["base"] == "base"
+    assert c["steps"][0]["value"] == "/opt/x/bin:" + df.DEFAULT_PATH
 
 
 @pytest.mark.parametrize("image", ["ghcr.io/org/img:1", "quay.io/org/img", "public.ecr.aws/x/y:2", "python:3.12", "library/python:3.12", "docker.io/library/node:20"])
 def test_allowlisted_registries(image):
-    assert df.compile_dockerfile(f"FROM {image}")["steps"]
+    assert df.compile_dockerfile(f"FROM {image}")["fromImage"] == image
 
 
 @pytest.mark.parametrize("image", ["evil.example.com/a:1", "localhost:5000/a", "10.0.0.5/a", "registry.internal/a"])
@@ -101,15 +121,15 @@ def test_other_registries_refused(image):
         df.compile_dockerfile(f"FROM {image}")
 
 
-def test_import_switch_forces_import_for_debian_family():
+def test_import_switch_forces_from_image_for_debian_family():
     assert df.compile_dockerfile("FROM ubuntu:22.04")["steps"] == []
     forced = df.compile_dockerfile("FROM ubuntu:22.04", build_args={"SOLARI_IMPORT": "1"})
-    assert any("crane export" in s.get("command", "") for s in forced["steps"])
+    assert forced["fromImage"] == "ubuntu:22.04" and "base" not in forced
 
 
-def test_import_file_mounts_land_inside_the_root():
+def test_from_image_file_mounts_land_at_their_path():
     c = df.compile_dockerfile("FROM alpine", file_mounts={"/etc/x": "1"})
-    assert "/srv/root/etc/x" in c["steps"][-1]["command"]
+    assert c["fromImage"] == "alpine" and "/etc/x" in c["steps"][-1]["command"] and "/srv/root" not in c["steps"][-1]["command"]
 
 
 @pytest.mark.parametrize("bad", ["ENV A;B=1", "ENV $(id)=1", "ENV a-b=1"])
@@ -118,14 +138,6 @@ def test_env_names_are_validated_before_they_reach_the_env_file(bad):
         df.compile_dockerfile("FROM python:3.12-alpine\n" + bad)
 
 
-def test_the_no_shell_message_is_shell_quoted_for_odd_image_names():
-    import shlex
-
-    cmd = df.import_steps("ghcr.io/org/we'ird:1")[2]["command"]
-    inner = shlex.split(cmd)[2]  # bash -c '<script>': the script survives one level of shell parsing intact
-    words = shlex.split(inner.replace("{", " ").replace("}", " ").replace(";", " ; "))
-    assert any("ird:1 has no /bin/sh" in w for w in words)
-
 
 def test_env_path_prepend_expands_against_the_docker_default_path():
     c = df.compile_dockerfile("FROM ubuntu:22.04\nENV PATH=/opt/x/bin:$PATH\nENV PATH=${PATH}:/opt/y")

{solari_runloop_compat-0.1.0 → solari_runloop_compat-0.1.2}/tests/test_gateway_wire.py

@@ -179,6 +179,7 @@ async def test_durable_exec_start_wait_and_view():
         ("GET", "/sandboxes/sb%3A1/executions?limit=1"): {"executions": []},
         ("POST", "/sandboxes/sb%3A1/executions/ex_1/wait"): EXEC_DONE,
         ("POST", "/sandboxes/sb%3A1/executions"): EXEC_RUNNING,
+        ("GET", "/sandboxes/sb%3A1"): RAW,
     })
     res = await g.execute("sb:1", "echo o; exit 7")
     start = [c for c in s.calls if c[0] == "POST" and c[1].endswith("/executions")][0]
@@ -537,3 +538,32 @@ async def test_delete_snapshot_gives_up_after_the_bound_and_treats_404_as_done(m
 
     g2, _ = gw({("DELETE", "/snapshots/s"): _ex.NotFoundError("gone")})
     await g2.delete_snapshot("s")
+
+
+@pytest.mark.asyncio
+async def test_blueprint_from_image_refused_on_a_gateway_without_native_image_builds():
+    g, http = gw({("POST", "/templates"): {"templateId": "tpl_1", "name": "n", "status": "building"}, ("DELETE", "/templates/tpl_1"): {}})
+    with pytest.raises(sr.SolariCompatUnsupported, match="native image builds"):
+        await g.blueprint_create("n", {"kind": "sandbox", "fromImage": "golang:1.22", "packages": [], "steps": [], "localFiles": []}, None, None)
+    assert ("DELETE", "/templates/tpl_1", None) in http.calls
+
+
+@pytest.mark.asyncio
+async def test_blueprint_from_image_accepted_when_the_gateway_echoes_it():
+    g, http = gw({("POST", "/templates"): {"templateId": "tpl_2", "name": "n", "status": "building", "fromImage": "golang:1.22"}})
+    view = await g.blueprint_create("n", {"kind": "sandbox", "fromImage": "golang:1.22", "packages": [], "steps": [], "localFiles": []}, None, None)
+    assert view.id == "tpl_2" and not any(c[0] == "DELETE" for c in http.calls)
+
+
+async def test_durable_exec_on_a_native_image_build_avoids_the_login_shell():
+    # A login shell re-sources /etc/profile, which resets PATH on Debian images; Alpine has no bash at all.
+    g, s = gw({
+        ("GET", "/sandboxes/sb%3A1/executions?limit=1"): {"executions": []},
+        ("POST", "/sandboxes/sb%3A1/executions/ex_1/wait"): EXEC_DONE,
+        ("POST", "/sandboxes/sb%3A1/executions"): EXEC_RUNNING,
+        ("GET", "/sandboxes/sb%3A1"): {**RAW, "fromImage": "docker.io/library/golang:1.22"},
+    })
+    await g.execute("sb:1", "echo $PATH")
+    start = [c for c in s.calls if c[0] == "POST" and c[1].endswith("/executions")][0]
+    assert start[2]["cmd"] == "/bin/sh" and start[2]["args"][0] == "-c" and "-l" not in start[2]["args"][0]
+    assert "/bin/bash -c" in start[2]["args"][1] and start[2]["args"][-1] == g._remote_script()

{solari_runloop_compat-0.1.0 → solari_runloop_compat-0.1.2}/tests/test_live_staging.py

@@ -235,3 +235,19 @@ def test_phase2_name_update_paging_and_async_snapshot(sdk: sr.RunloopSDK, cleanu
     assert done.status == "ready" and done.name == "p2-snap" and done.metadata == {"m": "1"}
     up = snap.update(name="p2-snap2", metadata={"m": "2"})
     assert up.name == "p2-snap2" and up.metadata == {"m": "2"}
+
+
+def test_from_image_keeps_the_images_own_path(sdk: sr.RunloopSDK, cleanup: List) -> None:
+    """F30: FROM golang must keep /go/bin:/usr/local/go/bin on PATH, also behind an `ENV PATH=/opt/x/bin:$PATH`."""
+    bp = sdk.blueprint.create(
+        name=f"compat-go-{int(time.time())}",
+        dockerfile="FROM golang:1.22\nENV PATH=/opt/x/bin:$PATH\nRUN mkdir -p /opt/x/bin\n",
+    )
+    try:
+        devbox = bp.create_devbox()
+        cleanup.append(("devbox", devbox.id))
+        out = devbox.cmd.exec("echo $PATH; which go").stdout()
+        assert out.splitlines()[0].startswith("/opt/x/bin:/go/bin:/usr/local/go/bin:")
+        assert out.splitlines()[1] == "/usr/local/go/bin/go"
+    finally:
+        bp.delete()

{solari_runloop_compat-0.1.0 → solari_runloop_compat-0.1.2}/tests/test_mapping.py

@@ -42,7 +42,7 @@ def test_unknown_size_is_a_400():
 
 @pytest.mark.parametrize(
     "state,status",
-    [("starting", "initializing"), ("running", "running"), ("paused", "suspended"), ("archived", "suspended"), ("releasing", "shutdown"), ("gone", "shutdown"), ("???", "failure")],
+    [("starting", "initializing"), ("running", "running"), ("paused", "suspended"), ("archived", "suspended"), ("stopped", "shutdown"), ("releasing", "shutdown"), ("gone", "shutdown"), ("???", "failure")],
 )
 def test_status_map(state, status):
     assert mp.map_status(state) == status
@@ -117,3 +117,43 @@ def test_shell_wrap_and_tail():
 
 def test_open_tunnel_at_create_is_accepted():
     assert mp.create_body(tunnel={"auth_mode": "open"}) == {}
+
+
+def _run_native(script_cmd, *, bash_path="/bin/bash"):
+    import subprocess
+
+    cmd, args = mp.shell_wrap(script_cmd, native=True)
+    args = [a.replace("/bin/bash", bash_path) for a in args[:2]] + args[2:]
+    return subprocess.run([cmd, *args], capture_output=True, text=True, timeout=20)
+
+
+def test_shell_wrap_plain_devbox_keeps_the_login_bash():
+    assert mp.shell_wrap("echo hi") == ("/bin/bash", ["-lc", "echo hi"])
+
+
+def test_shell_wrap_native_runs_bash_when_the_image_has_it():
+    import os
+
+    if not os.access("/bin/bash", os.X_OK):
+        pytest.skip("no /bin/bash on this machine")
+    r = _run_native('[[ a == a ]] && echo "bash:$0:${BASH_VERSION:+yes}"; echo {x,y}')
+    assert r.returncode == 0 and "bash:" in r.stdout and "yes" in r.stdout and "x y" in r.stdout
+
+
+def test_shell_wrap_native_falls_back_to_sh_when_the_image_has_no_bash():
+    r = _run_native("echo fallback-ok; echo \"$0\"", bash_path="/nonexistent/bash")
+    assert r.returncode == 0 and "fallback-ok" in r.stdout
+
+
+def test_shell_wrap_native_is_not_a_login_shell():
+    import os
+
+    r = _run_native("shopt -q login_shell && echo login || echo notlogin") if os.access("/bin/bash", os.X_OK) else None
+    if r is not None:
+        assert "notlogin" in r.stdout
+
+
+def test_shell_wrap_native_passes_the_command_as_one_argument():
+    cmd, args = mp.shell_wrap("echo 'a b' \"$HOME\"; exit 3", native=True)
+    assert args[-1] == "echo 'a b' \"$HOME\"; exit 3" and args[-2] == "sh"
+    assert _run_native("exit 3").returncode == 3

solari_runloop_compat-0.1.0/solari_runloop/_guest/solari-run.sh

@@ -1,14 +0,0 @@
-#!/bin/sh
-# usage: solari-run '<shell command>'   runs inside the imported image root (/etc/solari-rootdir).
-# Image import is a compatibility layer over a chroot in the customer's own microVM; it is not a security boundary.
-set -e
-R=$(cat /etc/solari-rootdir)
-mkdir -p "$R/proc" "$R/dev" "$R/sys" "$R/tmp" "$R/etc"
-mountpoint -q "$R/proc" || mount --bind /proc "$R/proc"
-mountpoint -q "$R/dev" || mount --rbind /dev "$R/dev"
-mountpoint -q "$R/sys" || mount --rbind /sys "$R/sys"
-cp /etc/resolv.conf "$R/etc/resolv.conf" 2>/dev/null || true
-set -a; [ -f /etc/solari-env ] && . /etc/solari-env; set +a
-SOLARI_WD=$(cat /etc/solari-workdir 2>/dev/null || echo /); SOLARI_CMD="$1"; export SOLARI_WD SOLARI_CMD
-if [ -x "$R/bin/bash" ]; then SH=/bin/bash; else SH=/bin/sh; fi
-exec chroot "$R" "$SH" -c 'cd "$SOLARI_WD" 2>/dev/null || cd /; eval "$SOLARI_CMD"'

solari_runloop_compat-0.1.0/solari_runloop/_guest/solari_extract.py

@@ -1,101 +0,0 @@
-#!/usr/bin/env python3
-"""Extract a tar stream (``crane export``) into a root directory, refusing anything that could write outside it.
-
-usage: solari-extract <root> [max-bytes] < image.tar
-Guards (each has a test in tests/test_extract.py that fails without it):
-  absolute member names, ``..`` components, writes through a symlink that leaves the root, hardlinks that leave the root,
-  device nodes / fifos (skipped), setuid/setgid/sticky bits (stripped), total size and member-count caps.
-Runs as root inside the customer's own sandbox; this is defence in depth, the microVM is the boundary.
-"""
-import os
-import sys
-import tarfile
-
-MAX_MEMBERS = 400_000
-
-
-class Refused(Exception):
-    pass
-
-
-def extract(stream, root, max_bytes=4 << 30):
-    root = os.path.realpath(root)
-
-    def inside(p):
-        return p == root or p.startswith(root + os.sep)
-
-    total = count = skipped = 0
-    with tarfile.open(fileobj=stream, mode="r|") as tf:
-        for m in tf:
-            count += 1
-            total += max(m.size, 0)
-            if count > MAX_MEMBERS:
-                raise Refused("too many archive members")
-            if total > max_bytes:
-                raise Refused(f"image larger than the {max_bytes} byte cap")
-            if m.name.startswith("/"):
-                raise Refused(f"absolute member name {m.name!r}")
-            name = os.path.normpath(m.name)
-            if name == ".":
-                continue
-            if name == ".." or name.startswith("../"):
-                raise Refused(f"member escapes the root: {m.name!r}")
-            dest = os.path.join(root, name)
-            parent = os.path.realpath(os.path.dirname(dest))
-            if not inside(parent):
-                raise Refused(f"member {m.name!r} resolves outside the root through a symlink")
-            dest = os.path.join(parent, os.path.basename(dest))
-            if m.isdir():
-                if os.path.islink(dest):
-                    os.unlink(dest)
-                os.makedirs(dest, exist_ok=True)
-                os.chmod(dest, (m.mode & 0o777) | 0o700)
-                continue
-            if os.path.lexists(dest) and not os.path.isdir(dest) or os.path.islink(dest):
-                os.unlink(dest)
-            if m.isreg():
-                fd = os.open(dest, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, m.mode & 0o777)
-                with os.fdopen(fd, "wb") as out:
-                    src = tf.extractfile(m)
-                    while True:
-                        chunk = src.read(1 << 20)
-                        if not chunk:
-                            break
-                        out.write(chunk)
-                os.chmod(dest, m.mode & 0o777)
-            elif m.issym():
-                os.symlink(m.linkname, dest)
-            elif m.islnk():
-                tname = os.path.normpath(m.linkname)
-                if m.linkname.startswith("/") or tname == ".." or tname.startswith("../"):
-                    raise Refused(f"hardlink target escapes the root: {m.linkname!r}")
-                target = os.path.realpath(os.path.join(root, tname))
-                if not inside(target) or not os.path.isfile(target):
-                    raise Refused(f"hardlink target outside the root or missing: {m.linkname!r}")
-                os.link(target, dest)
-                continue
-            else:
-                skipped += 1  # device nodes, fifos
-                continue
-            try:
-                os.lchown(dest, m.uid, m.gid)
-            except OSError:
-                pass
-    return count, skipped
-
-
-def main(argv):
-    if len(argv) < 2:
-        print(__doc__, file=sys.stderr)
-        return 2
-    try:
-        n, skipped = extract(sys.stdin.buffer, argv[1], int(argv[2]) if len(argv) > 2 else 4 << 30)
-    except Refused as e:
-        print(f"solari-extract: refused: {e}", file=sys.stderr)
-        return 3
-    print(f"solari-extract: {n} members, {skipped} device nodes skipped", file=sys.stderr)
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main(sys.argv))

solari_runloop_compat-0.1.0/solari_runloop/_guest/solari_sizecheck.py

@@ -1,14 +0,0 @@
-#!/usr/bin/env python3
-"""usage: solari-size-check <image> <max-compressed-bytes>: refuse an image whose compressed layers exceed the cap
-(read from the registry manifest before anything is downloaded)."""
-import json
-import subprocess
-import sys
-
-image, cap = sys.argv[1], int(sys.argv[2])
-m = json.loads(subprocess.check_output(["crane", "manifest", "--platform", "linux/amd64", image]))
-if "layers" not in m:
-    sys.exit("solari: image manifest has no layers (multi-arch index without linux/amd64?)")
-size = sum(layer.get("size", 0) for layer in m["layers"])
-if size > cap:
-    sys.exit(f"solari: image is {size} bytes compressed, the cap is {cap}")

solari_runloop_compat-0.1.0/tests/test_extract.py

@@ -1,111 +0,0 @@
-"""The tar extractor's guards. Each test fails if the matching check in _guest/solari_extract.py is removed."""
-
-from __future__ import annotations
-
-import importlib.util
-import io
-import os
-import stat
-import tarfile
-from pathlib import Path
-
-import pytest
-
-spec = importlib.util.spec_from_file_location("solari_extract", Path(__file__).parent.parent / "solari_runloop" / "_guest" / "solari_extract.py")
-se = importlib.util.module_from_spec(spec)
-spec.loader.exec_module(se)
-
-
-def tar_of(*members):
-    buf = io.BytesIO()
-    with tarfile.open(fileobj=buf, mode="w") as tf:
-        for info, data in members:
-            tf.addfile(info, io.BytesIO(data) if data is not None else None)
-    buf.seek(0)
-    return buf
-
-
-def f(name, data=b"x", mode=0o644):
-    i = tarfile.TarInfo(name)
-    i.size = len(data)
-    i.mode = mode
-    return i, data
-
-
-def link(name, target, hard=False):
-    i = tarfile.TarInfo(name)
-    i.type = tarfile.LNKTYPE if hard else tarfile.SYMTYPE
-    i.linkname = target
-    return i, None
-
-
-def d(name):
-    i = tarfile.TarInfo(name)
-    i.type = tarfile.DIRTYPE
-    i.mode = 0o755
-    return i, None
-
-
-def test_normal_extraction(tmp_path):
-    se.extract(tar_of(d("etc"), f("etc/os-release", b"A"), link("bin", "usr/bin"), d("usr"), d("usr/bin")), tmp_path)
-    assert (tmp_path / "etc/os-release").read_bytes() == b"A" and os.path.islink(tmp_path / "bin")
-
-
-def test_absolute_name_refused(tmp_path):
-    with pytest.raises(se.Refused, match="absolute"):
-        se.extract(tar_of(f("/etc/passwd")), tmp_path)
-
-
-@pytest.mark.parametrize("name", ["../evil", "a/../../evil", ".."])
-def test_dotdot_refused(tmp_path, name):
-    with pytest.raises(se.Refused, match="escapes"):
-        se.extract(tar_of(f(name)), tmp_path / "root")
-
-
-def test_write_through_symlink_out_of_root_refused(tmp_path):
-    root = tmp_path / "root"
-    root.mkdir()
-    outside = tmp_path / "outside"
-    outside.mkdir()
-    with pytest.raises(se.Refused, match="symlink"):
-        se.extract(tar_of(link("evil", str(outside)), f("evil/pwned", b"x")), root)
-    assert not (outside / "pwned").exists()
-
-
-def test_relative_symlink_escape_refused(tmp_path):
-    root = tmp_path / "root"
-    root.mkdir()
-    with pytest.raises(se.Refused):
-        se.extract(tar_of(link("up", "../.."), f("up/pwned")), root)
-
-
-def test_hardlink_out_of_root_refused(tmp_path):
-    root = tmp_path / "root"
-    root.mkdir()
-    (tmp_path / "secret").write_text("s")
-    with pytest.raises(se.Refused, match="hardlink"):
-        se.extract(tar_of(link("h", "../secret", hard=True)), root)
-    with pytest.raises(se.Refused, match="hardlink"):
-        se.extract(tar_of(link("h", "/etc/passwd", hard=True)), root)
-
-
-def test_hardlink_inside_root_ok(tmp_path):
-    se.extract(tar_of(f("a", b"1"), link("b", "a", hard=True)), tmp_path)
-    assert (tmp_path / "b").read_bytes() == b"1"
-
-
-def test_device_nodes_skipped(tmp_path):
-    i = tarfile.TarInfo("dev-null")
-    i.type = tarfile.CHRTYPE
-    n, skipped = se.extract(tar_of((i, None), f("ok")), tmp_path)
-    assert skipped == 1 and not (tmp_path / "dev-null").exists() and (tmp_path / "ok").exists()
-
-
-def test_setuid_bits_stripped(tmp_path):
-    se.extract(tar_of(f("su", b"x", mode=0o4755)), tmp_path)
-    assert not (os.stat(tmp_path / "su").st_mode & (stat.S_ISUID | stat.S_ISGID | stat.S_ISVTX))
-
-
-def test_size_cap(tmp_path):
-    with pytest.raises(se.Refused, match="cap"):
-        se.extract(tar_of(f("big", b"x" * 2000)), tmp_path, max_bytes=1000)