feat: support smolmachines bottle commit

bot_bottle/backend/smolmachines/launch.py

@@ -40,8 +40,12 @@ from ..docker.git_gate import (
     GIT_GATE_HOOK_IN_CONTAINER,
 )
 from ...git_gate import revoke_git_gate_provisioned_keys
-from ...log import warn
-from ...bottle_state import egress_state_dir, git_gate_state_dir
+from ...log import info, warn
+from ...bottle_state import (
+    egress_state_dir,
+    git_gate_state_dir,
+    read_committed_image,
+)
 from . import loopback_alias as _loopback
 from . import sidecar_bundle as _bundle
 from . import smolvm as _smolvm
@@ -85,14 +89,7 @@ def launch(
         plan = _start_bundle(plan, network, loopback_ip, stack)
         plan = _discover_urls(plan, loopback_ip)
 
-        # Build the agent image and pack it into a `.smolmachine`
-        # artifact (or hit the per-Dockerfile-digest cache). Runs
-        # here, not in prepare, so the docker-build output doesn't
-        # garble the dashboard's preflight modal.
-        agent_from_path = _ensure_smolmachine(
-            plan.agent_image,
-            dockerfile=plan.agent_dockerfile_path,
-        )
+        agent_from_path = _agent_from_path(plan)
 
         _launch_vm(plan, agent_from_path, loopback_ip, stack)
         _init_vm(plan)
@@ -386,6 +383,30 @@ def _resolve_token_env(
     return egress_resolve_token_values(plan.egress_plan.token_env_map, effective_env)
 
 
+def _agent_from_path(plan: SmolmachinesBottlePlan) -> Path:
+    """Return the `.smolmachine` artifact used for `machine create --from`.
+
+    Prefer a committed VM artifact when one is recorded and still
+    present. If the file was removed, fall back to the normal image
+    build + pack cache path.
+    """
+    committed = read_committed_image(plan.slug)
+    if committed:
+        committed_path = Path(committed)
+        if committed_path.is_file():
+            info(f"using committed smolmachine {str(committed_path)!r}")
+            return committed_path
+
+    # Build the agent image and pack it into a `.smolmachine`
+    # artifact (or hit the per-Dockerfile-digest cache). Runs here,
+    # not in prepare, so the docker-build output doesn't garble the
+    # dashboard's preflight modal.
+    return _ensure_smolmachine(
+        plan.agent_image,
+        dockerfile=plan.agent_dockerfile_path,
+    )
+
+
 def _ensure_smolmachine(image_ref: str, *, dockerfile: str = "") -> Path:
     """Build the agent docker image and convert it into a
     `.smolmachine` artifact, caching the result under

bot_bottle/backend/smolmachines/smolvm.py

@@ -94,6 +94,16 @@ def pack_create(image: str, output: Path) -> None:
     _smolvm("pack", "create", "--image", image, "-o", str(output))
 
 
+def pack_create_from_vm(name: str, output: Path) -> None:
+    """`smolvm pack create --from-vm <name> -o <output>`.
+
+    Snapshots an existing persistent VM into a pack artifact. As
+    with `pack_create`, smolvm writes a launcher at `output` and the
+    bootable sidecar at `output.smolmachine`.
+    """
+    _smolvm("pack", "create", "--from-vm", name, "-o", str(output))
+
+
 # --- Machine lifecycle ---------------------------------------------------
 
 

bot_bottle/cli/commit.py

@@ -1,20 +1,21 @@
-"""commit: freeze a running Docker bottle's container state to a local image.
+"""commit: freeze a running bottle's state to a resumable artifact.
 
-Runs `docker commit <container> <image-tag>` on the active agent
-container and stores the image tag in per-bottle state so the next
-`./cli.py resume <slug>` boots from that snapshot instead of
-rebuilding from the Dockerfile.
-
-Only the Docker backend is supported. Smolmachines VMs have no
-container-level commit API in the current smolvm CLI surface.
+Docker bottles are committed to a local Docker image. Smolmachines
+bottles are packed from the running VM into a `.smolmachine` artifact.
+The resulting reference is stored in per-bottle state so the next
+`./cli.py resume <slug>` boots from the snapshot instead of rebuilding
+from the Dockerfile.
 """
 
 from __future__ import annotations
 
 import argparse
+from pathlib import Path
 
 from ..backend import enumerate_active_agents
 from ..backend.docker.util import commit_container
+from ..backend.smolmachines.smolvm import pack_create_from_vm
+from ..bottle_state import bottle_state_dir
 from ..bottle_state import mark_preserved, read_metadata, write_committed_image
 from ..log import die, info
 from ._common import PROG
@@ -23,6 +24,7 @@ from . import tui
 
 _COMMITTED_IMAGE_PREFIX = "bot-bottle-committed-"
 _DOCKER_BACKENDS = {"docker", ""}
+_SMOLMACHINES_BACKEND = "smolmachines"
 
 
 def _committed_image_tag(slug: str) -> str:
@@ -33,6 +35,19 @@ def _agent_container_name(slug: str) -> str:
     return f"bot-bottle-{slug}"
 
 
+def _agent_machine_name(slug: str) -> str:
+    return f"bot-bottle-{slug}"
+
+
+def _committed_smolmachine_output(slug: str) -> Path:
+    return bottle_state_dir(slug) / "committed-smolmachine"
+
+
+def _committed_smolmachine_artifact(slug: str) -> Path:
+    output = _committed_smolmachine_output(slug)
+    return output.with_name(f"{output.name}.smolmachine")
+
+
 def cmd_commit(argv: list[str]) -> int:
     parser = argparse.ArgumentParser(prog=f"{PROG} commit", add_help=True)
     parser.add_argument(
@@ -58,18 +73,33 @@ def cmd_commit(argv: list[str]) -> int:
 
     metadata = read_metadata(slug)
     backend = metadata.backend if metadata else ""
-    if backend not in _DOCKER_BACKENDS:
+    if backend in _DOCKER_BACKENDS:
+        container = _agent_container_name(slug)
+        image_tag = _committed_image_tag(slug)
+
+        commit_container(container, image_tag)
+        write_committed_image(slug, image_tag)
+        mark_preserved(slug)
+        info(f"to resume from this snapshot: ./cli.py resume {slug}")
+        info(f"to export for migration:      docker save {image_tag} -o {slug}.tar")
+        return 0
+
+    if backend == _SMOLMACHINES_BACKEND:
+        machine = _agent_machine_name(slug)
+        output = _committed_smolmachine_output(slug)
+        output.parent.mkdir(parents=True, exist_ok=True)
+        pack_create_from_vm(machine, output)
+        artifact = _committed_smolmachine_artifact(slug)
+        write_committed_image(slug, str(artifact))
+        mark_preserved(slug)
+        info(f"to resume from this snapshot: ./cli.py resume {slug}")
+        info(f"to export for migration:      cp {artifact} {slug}.smolmachine")
+        return 0
+
+    if backend:
         die(
-            f"commit is only supported for the docker backend; "
+            f"commit is only supported for the docker and smolmachines backends; "
             f"bottle {slug!r} uses {backend!r}"
         )
-
-    container = _agent_container_name(slug)
-    image_tag = _committed_image_tag(slug)
-
-    commit_container(container, image_tag)
-    write_committed_image(slug, image_tag)
-    mark_preserved(slug)
-    info(f"to resume from this snapshot: ./cli.py resume {slug}")
-    info(f"to export for migration:      docker save {image_tag} -o {slug}.tar")
-    return 0
+    die(f"commit cannot determine the backend for bottle {slug!r}")
+    return 1