@claxedo/sandbox-manager 0.10.0 → 0.10.2

package/dist/drivers/boat.mjs

@@ -49,6 +49,13 @@ var SandboxRuntimeBootError = class extends Error {
     this.name = "SandboxRuntimeBootError";
   }
 };
+var SandboxImageDownloadError = class extends Error {
+  imageDownloadFailed = true;
+  constructor(reason) {
+    super(reason);
+    this.name = "SandboxImageDownloadError";
+  }
+};
 var SandboxHostGoneError = class extends Error {
   hostGone = true;
   constructor(reason) {
@@ -149,6 +156,13 @@ function envFile(input) {
   }).join("\n") + "\n";
 }
 
+// src/runtime-version.ts
+var SERVED_WORKSPACE_RUNTIME_FLOOR = {
+  version: "0.10.1",
+  image: "ghcr.io/kyashrathore/claxedo-sandbox:workspace-runtime-0-10-1-40706b7356-agent-plugins-v8"
+};
+var MINIMUM_SERVED_WORKSPACE_RUNTIME_VERSION = SERVED_WORKSPACE_RUNTIME_FLOOR.version;
+
 // src/image-name.ts
 function assertSandboxImageReference(image) {
   if (!image || image !== image.trim() || image.startsWith("-") || /\s/.test(image)) {
@@ -560,6 +574,98 @@ function isTransientDriverError(err, markers) {
 }
 var TRANSIENT_DRIVER_RETRY_MS = 2e3;
 
+// src/drivers/boat-machine.ts
+var IMAGE_PREPARATION_TIMEOUT_SECONDS = 600;
+var CONTAINER_START_TIMEOUT_SECONDS = 120;
+var DEFAULT_CONTAINER_NAME = "claxedo-runtime";
+var DOCKER_DAEMON_WAIT_SECONDS = 120;
+var RUNTIME_ENV_PATH = ".claxedo-runtime-env";
+var REGISTRY_PASSWORD_PATH = ".claxedo-registry-password";
+var BOOT_LOCK_PATH = "/run/lock/claxedo-boot.lock";
+var BOOT_LOCK_HEADROOM_SECONDS = 60;
+var CONTAINER_ENV_PATH = "/run/claxedo-runtime.env";
+var PERSISTENT_ROOT = "claxedo-persistent";
+var PERSISTENT_HOME_MOUNTS = [["claxedo", "/root/.claxedo"], ["workspace-runtime", "/root/.workspace-runtime"]];
+var IMAGE_TREES = ["root", "usr", "etc", "var", "opt", "home", "srv"];
+var IMAGE_TREE_SEED_EXCLUDES = ["root/.cache", "root/.npm/_cacache"];
+var IMAGE_TREES_COMPLETE_MARKER = ".complete";
+var SEED_CONTAINER_NAME = "claxedo-seed";
+var STUB_IMAGE = "claxedo-runtime-stub";
+var STUB_IMAGE_ARCHIVE = "stub.tar";
+var IMAGE_LABEL = "claxedo.image";
+var IMAGE_ENV_FILE = "image.env";
+var ROOT_LINKS = ["bin", "lib", "lib64", "sbin"];
+var ROOT_DIRECTORIES = ["boot", "dev", "media", "mnt", "proc", "run", "sys", "tmp", ...IMAGE_TREES];
+var BOAT_SAVED_IMAGES = "/var/lib/ascii-docker-images";
+var DOCKER_NAME_IN_USE = "is already in use by container";
+var CONTAINER_CREATE_ATTEMPTS = 5;
+var CONTAINER_SECURITY_OPTIONS = "--security-opt seccomp=unconfined --security-opt apparmor=unconfined";
+var VM_DOCKER_INIT = "/usr/libexec/docker/docker-init";
+var CONTAINER_INIT_PATH = "/claxedo-init";
+function holdingBootLock(commandTimeoutSeconds, script) {
+  const wait = commandTimeoutSeconds - BOOT_LOCK_HEADROOM_SECONDS;
+  return `exec 9>>${BOOT_LOCK_PATH} && { flock -w ${wait} 9 || { echo "another boot of this machine held ${BOOT_LOCK_PATH} for ${wait} s" >&2; exit 1; }; } && ${script}`;
+}
+function containerHostname(workspaceId) {
+  return workspaceId.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/^-+|-+$/g, "").slice(0, 63) || "claxedo";
+}
+function bootedImageFile(staged) {
+  return `${staged.env}.image`;
+}
+function bootedImage(prepareStdout) {
+  return prepareStdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).pop();
+}
+var VERSION_FILE = "opt/workspace-runtime/workspace-runtime-version";
+var stubLabel = `docker image inspect --format '{{index .Config.Labels "${IMAGE_LABEL}"}}' ${STUB_IMAGE} 2>/dev/null`;
+var treesFunctions = [
+  `trees_of() { printf '%s/${PERSISTENT_ROOT}/image-%s' "$(pwd)" "$(printf %s "$1" | sed 's/[^A-Za-z0-9._-]/-/g')"; }`,
+  `seeded() { [ -f "$1/${IMAGE_TREES_COMPLETE_MARKER}" ] && [ -f "$1/${STUB_IMAGE_ARCHIVE}" ] && [ -f "$1/${IMAGE_ENV_FILE}" ]; }`,
+  `served() { version=$(cat "$1/${VERSION_FILE}" 2>/dev/null) && [ -n "$version" ] && [ "$(printf '%s\\n%s\\n' ${MINIMUM_SERVED_WORKSPACE_RUNTIME_VERSION} "$version" | sort -V | head -n 1)" = ${MINIMUM_SERVED_WORKSPACE_RUNTIME_VERSION} ]; }`
+].join(" && ");
+var IMAGE_DOWNLOAD_INTERRUPTED = "image_download_interrupted";
+var KEPT_IMAGE_SKIPPED = "kept_image_skipped:";
+var PULL_RESUMING = `pull_resuming() { finished=$(mktemp) && while :; do if output=$(docker pull "$1" 2>&1); then rm -f "$finished"; return 0; fi; case "$output" in *"connection reset by peer"*|*"unexpected EOF"*|*"i/o timeout"*|*"TLS handshake timeout"*) ;; *) printf '%s\\n' "$output" >&2; rm -f "$finished"; return 1 ;; esac; before=$(wc -l < "$finished"); { cat "$finished"; printf '%s\\n' "$output" | sed -n -e 's/^\\([0-9a-f]\\{12\\}\\): Download complete$/\\1/p' -e 's/^\\([0-9a-f]\\{12\\}\\): Pull complete$/\\1/p'; } | sort -u > "$finished.next" && mv "$finished.next" "$finished"; [ "$(wc -l < "$finished")" -gt "$before" ] || { printf '%s\\n' "$output" ${IMAGE_DOWNLOAD_INTERRUPTED} >&2; rm -f "$finished"; return 1; }; done; }`;
+function machineBootScripts(boot) {
+  const named = shell(boot.image);
+  const trees = `"$(trees_of ${named})"`;
+  const bootedFile = bootedImageFile(boot.staged);
+  const containerOfBooted = `[ "$(docker container inspect --format '{{index .Config.Labels "${IMAGE_LABEL}"}}' ${boot.containerName} 2>/dev/null)" = "$booted" ]`;
+  const bootScript = [
+    `. ${CONTAINER_ENV_PATH}`,
+    `mkdir -p ${shell(boot.directory)}`,
+    `cd ${shell(boot.directory)}`,
+    `exec ${boot.runtimeCommand}`
+  ].join(" && ");
+  const mounts = [["workspace", boot.directory], ...PERSISTENT_HOME_MOUNTS];
+  const run = `docker run -d --name ${boot.containerName} --hostname ${shell(containerHostname(boot.workspaceId))} -p ${boot.port}:${boot.port} -v ${VM_DOCKER_INIT}:${CONTAINER_INIT_PATH}:ro -v "$(pwd)/${RUNTIME_ENV_PATH}:${CONTAINER_ENV_PATH}:ro" --env-file "$trees/${IMAGE_ENV_FILE}" ` + IMAGE_TREES.map((tree) => `-v "$trees/${tree}":/${tree} `).join("") + mounts.map(([source, target]) => `-v "$(pwd)/${PERSISTENT_ROOT}/${source}":${shell(target)} `).join("") + `${CONTAINER_SECURITY_OPTIONS} --entrypoint ${CONTAINER_INIT_PATH} ${STUB_IMAGE} -- sh -lc ${shell(bootScript)}`;
+  const seedTrees = `sudo rm -rf ${trees} && sudo mkdir -p ${trees} && { docker rm -f ${SEED_CONTAINER_NAME} >/dev/null 2>&1 || true; } && docker create --name ${SEED_CONTAINER_NAME} ${named} true >/dev/null && for tree in ${IMAGE_TREES.join(" ")}; do docker cp ${SEED_CONTAINER_NAME}:/$tree - | sudo tar -xf - -C ${trees} ${IMAGE_TREE_SEED_EXCLUDES.map((exclude) => `--exclude=${exclude}`).join(" ")} && [ -d ${trees}/$tree ] || exit 1; done && docker rm ${SEED_CONTAINER_NAME} >/dev/null && sudo touch ${trees}/${IMAGE_TREES_COMPLETE_MARKER}`;
+  const seedStub = `stub=$(mktemp -d) && docker image inspect --format '{{range .Config.Env}}{{println .}}{{end}}' ${named} > "$stub/${IMAGE_ENV_FILE}" && workdir=$(docker image inspect --format '{{or .Config.WorkingDir "/"}}' ${named}) && mkdir "$stub/root" ${ROOT_DIRECTORIES.map((directory) => `"$stub/root/${directory}"`).join(" ")} && ${ROOT_LINKS.map((link) => `ln -s usr/${link} "$stub/root/${link}"`).join(" && ")} && chmod 1777 "$stub/root/tmp" && tar --owner=0 --group=0 --numeric-owner -cf "$stub/skeleton.tar" -C "$stub/root" . && docker import --change "WORKDIR $workdir" --change ${shell(`LABEL ${IMAGE_LABEL}=${boot.image}`)} "$stub/skeleton.tar" ${STUB_IMAGE} >/dev/null && docker save -o "$stub/${STUB_IMAGE_ARCHIVE}" ${STUB_IMAGE} && sudo mv "$stub/${IMAGE_ENV_FILE}" "$stub/${STUB_IMAGE_ARCHIVE}" ${trees}/ && rm -rf "$stub"`;
+  const seedNamed = `{ docker image inspect ${named} >/dev/null 2>&1 || pull_resuming ${named}; } && { [ -f ${trees}/${IMAGE_TREES_COMPLETE_MARKER} ] || { ${seedTrees}; }; } && ${seedStub}`;
+  const keepPrevious = `previous=$(${stubLabel}) && [ -n "$previous" ] && seeded "$(trees_of "$previous")" && served "$(trees_of "$previous")"`;
+  const keptImageSkipped = `echo "${KEPT_IMAGE_SKIPPED} stub=\${previous:-none} seeded=$(seeded "$(trees_of "$previous")" && echo yes || echo no) version=$(cat "$(trees_of "$previous")/${VERSION_FILE}" 2>/dev/null || echo none)" >&2`;
+  const removeImage = `if docker image inspect "$booted" >/dev/null 2>&1; then leftovers=$(docker ps -aq --filter ancestor="$booted") && { [ -z "$leftovers" ] || docker rm -f $leftovers >/dev/null; } && id=$(docker image inspect --format '{{.Id}}' "$booted") && docker rmi "$booted" >/dev/null && sudo rm -f ${BOAT_SAVED_IMAGES}/"\${id#sha256:}".tar; fi`;
+  const prepare = [
+    `chmod 600 ${boot.staged.env}`,
+    `find . -maxdepth 1 \\( -name '${RUNTIME_ENV_PATH}.*' -o -name '${REGISTRY_PASSWORD_PATH}.*' \\) -mmin +${boot.staleStagedMinutes} -exec rm -f {} +`,
+    `timeout ${DOCKER_DAEMON_WAIT_SECONDS} sh -c 'until docker info >/dev/null 2>&1; do sleep 1; done'`,
+    `[ -x ${VM_DOCKER_INIT} ]`,
+    ...boot.registry && boot.staged.password ? [`{ chmod 600 ${boot.staged.password}; docker login ${shell(boot.registry.server)} --username ${shell(boot.registry.username)} --password-stdin < ${boot.staged.password}; rc=$?; rm -f ${boot.staged.password}; (exit $rc); }`] : [],
+    treesFunctions,
+    PULL_RESUMING,
+    `booted=${named}`,
+    `if ! seeded ${trees}; then ` + (boot.keepPreviousImage ? `if ${keepPrevious}; then booted=$previous; else ${keptImageSkipped}; ${seedNamed}; fi` : seedNamed) + `; fi`,
+    `{ [ "$(${stubLabel})" = "$booted" ] || docker load -i "$(trees_of "$booted")/${STUB_IMAGE_ARCHIVE}" >/dev/null; }`,
+    `sudo find "$(pwd)/${PERSISTENT_ROOT}" -mindepth 1 -maxdepth 1 -name 'image-*' ! -path "$(trees_of "$booted")" -exec rm -rf {} +`,
+    `printf '%s\\n' "$booted" > ${bootedFile}`,
+    `printf '%s\\n' "$booted"`
+  ];
+  const start = `${treesFunctions} && booted=$(cat ${bootedFile}) && trees=$(trees_of "$booted") && rm -f ${bootedFile} && mv -f ${boot.staged.env} ${RUNTIME_ENV_PATH} && up=; for attempt in $(seq ${CONTAINER_CREATE_ATTEMPTS}); do [ "$attempt" = 1 ] || sleep 1; if ${containerOfBooted}; then failure=$(docker start ${boot.containerName} 2>&1 >/dev/null) && { up=1; break; }; else docker rm -f ${boot.containerName} >/dev/null 2>&1; failure=$(${run} 2>&1 >/dev/null) && { up=1; break; }; fi; case "$failure" in *${shell(DOCKER_NAME_IN_USE)}*) ;; *) break ;; esac; done; [ -n "$up" ] || { echo "$failure" >&2; false; } && ${removeImage}`;
+  return {
+    prepare: holdingBootLock(IMAGE_PREPARATION_TIMEOUT_SECONDS, prepare.join(" && ")),
+    start: holdingBootLock(CONTAINER_START_TIMEOUT_SECONDS, start)
+  };
+}
+
 // src/drivers/boat.ts
 function formatBoatRuntimeTemplate(template) {
   return JSON.stringify({ image: template.image, shareCode: template.shareCode });
@@ -579,7 +685,6 @@ function parseBoatRuntimeTemplate(setting) {
 }
 var DEFAULT_RUNTIME_COMMAND = "/usr/local/bin/workspace-runtime";
 var DEFAULT_WORKSPACE_DIR = "/workspace";
-var DEFAULT_CONTAINER_NAME = "claxedo-runtime";
 var DEFAULT_PROVISION_TIMEOUT_MS = 12e4;
 var DEFAULT_STATE_POLL_MS = { firstMs: 250, maxMs: 2e3 };
 var DEFAULT_HEALTH_TIMEOUT_MS = 10 * 6e4;
@@ -587,35 +692,8 @@ var DEFAULT_HEALTH_INTERVAL_MS = 100;
 var HEALTH_PROBE_WINDOW_SECONDS = 50;
 var HEALTH_PROBE_MARGIN_SECONDS = 10;
 var BOOTING_CONTAINER_STATES = /* @__PURE__ */ new Set(["running", "paused"]);
-var IMAGE_PREPARATION_TIMEOUT_SECONDS = 600;
-var CONTAINER_START_TIMEOUT_SECONDS = 120;
 var HOST_PUBLISH_TIMEOUT_SECONDS = 120;
 var BOOT_TTL_SECONDS = 30 * 60;
-var DOCKER_DAEMON_WAIT_SECONDS = 120;
-var RUNTIME_ENV_PATH = ".claxedo-runtime-env";
-var REGISTRY_PASSWORD_PATH = ".claxedo-registry-password";
-var BOOT_LOCK_PATH = "/run/lock/claxedo-boot.lock";
-var BOOT_LOCK_HEADROOM_SECONDS = 60;
-var CONTAINER_ENV_PATH = "/run/claxedo-runtime.env";
-var PERSISTENT_ROOT = "claxedo-persistent";
-var PERSISTENT_HOME_MOUNTS = [["claxedo", "/root/.claxedo"], ["workspace-runtime", "/root/.workspace-runtime"]];
-var IMAGE_TREES = ["root", "usr", "etc", "var", "opt", "home", "srv"];
-var IMAGE_TREE_SEED_EXCLUDES = ["root/.cache", "root/.npm/_cacache"];
-var IMAGE_TREES_COMPLETE_MARKER = ".complete";
-var SEED_CONTAINER_NAME = "claxedo-seed";
-var STUB_IMAGE = "claxedo-runtime-stub";
-var STUB_IMAGE_ARCHIVE = "stub.tar";
-var IMAGE_LABEL = "claxedo.image";
-var IMAGE_ENV_FILE = "image.env";
-var ROOT_LINKS = ["bin", "lib", "lib64", "sbin"];
-var ROOT_DIRECTORIES = ["boot", "dev", "media", "mnt", "proc", "run", "sys", "tmp", ...IMAGE_TREES];
-var BOAT_SAVED_IMAGES = "/var/lib/ascii-docker-images";
-var BOAT_CONTAINER_RECORD = "/etc/ascii-docker.json";
-var DOCKER_NAME_IN_USE = "is already in use by container";
-var CONTAINER_CREATE_ATTEMPTS = 5;
-var CONTAINER_SECURITY_OPTIONS = "--security-opt seccomp=unconfined --security-opt apparmor=unconfined";
-var VM_DOCKER_INIT = "/usr/libexec/docker/docker-init";
-var CONTAINER_INIT_PATH = "/claxedo-init";
 var CONTAINER_STOP_GRACE_SECONDS = 30;
 var HOST_RELAY_NOT_STOPPED = "The sandbox could not stop the localhost relay of this port. Try again.";
 var STDERR_TAIL_CHARS = 600;
@@ -627,16 +705,6 @@ var GONE_CODES = /* @__PURE__ */ new Set(["not_found", "snapshot_data_expired"])
 var RESUME_UNDER_WAY = "sandbox_resuming";
 var NOT_RUNNING_CODES = /* @__PURE__ */ new Set(["machine_not_running", "sandbox_not_ready"]);
 var TEMPLATE_UNREADABLE_CODES = /* @__PURE__ */ new Set(["snapshot_not_found", "api_key_action_forbidden", "api_key_sandbox_forbidden"]);
-function boatTemplateResetCommand() {
-  const bootFiles = [
-    `${PERSISTENT_ROOT}/workspace`,
-    ...PERSISTENT_HOME_MOUNTS.map(([source]) => `${PERSISTENT_ROOT}/${source}`),
-    RUNTIME_ENV_PATH,
-    `${RUNTIME_ENV_PATH}.*`,
-    `${REGISTRY_PASSWORD_PATH}.*`
-  ];
-  return `{ docker rm -f ${DEFAULT_CONTAINER_NAME} >/dev/null 2>&1 || true; } && sudo rm -rf ${bootFiles.join(" ")} && [ -z "$(docker ps -aq)" ] && echo '[]' | sudo tee ${BOAT_CONTAINER_RECORD} >/dev/null && sudo find ${BOAT_SAVED_IMAGES} -mindepth 1 -delete && ls -d ${PERSISTENT_ROOT}/image-*/${IMAGE_TREES_COMPLETE_MARKER}`;
-}
 function hostGoneOrThrow(err) {
   if (err instanceof BoatApiError && GONE_CODES.has(err.code)) throw new SandboxHostGoneError(err.message);
   throw err;
@@ -649,10 +717,6 @@ function archivedOrThrow(err) {
   if (err instanceof BoatApiError && err.code === "stop_failed" && err.sandboxState === "archived") return;
   hostGoneOrThrow(err);
 }
-function holdingBootLock(commandTimeoutSeconds, script) {
-  const wait = commandTimeoutSeconds - BOOT_LOCK_HEADROOM_SECONDS;
-  return `exec 9>>${BOOT_LOCK_PATH} && { flock -w ${wait} 9 || { echo "another boot of this machine held ${BOOT_LOCK_PATH} for ${wait} s" >&2; exit 1; }; } && ${script}`;
-}
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -662,12 +726,6 @@ function scrubbed(text, secrets) {
 function scrubbedTail(text, secrets) {
   return scrubbed(text, secrets).trim().slice(-STDERR_TAIL_CHARS);
 }
-function imageTreesDirectory(image) {
-  return `image-${image.replace(/[^A-Za-z0-9._-]/g, "-")}`;
-}
-function containerHostname(workspaceId) {
-  return workspaceId.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/^-+|-+$/g, "").slice(0, 63) || "claxedo";
-}
 var BoatDriverError = class extends Error {
   constructor(message) {
     super(message);
@@ -748,43 +806,6 @@ function createBoatSandboxDriver(options) {
       wait = Math.min(wait * 2, statePollMs.maxMs);
     }
   }
-  function containerScripts(input, staged) {
-    const port = runtimePort(input);
-    const directory = workspaceDirectory(input);
-    const reference = resolveImage(input);
-    const image = shell(reference);
-    const trees = `"$(pwd)/${PERSISTENT_ROOT}/${imageTreesDirectory(reference)}"`;
-    const labelledWithImage = (object, name) => `[ "$(docker ${object} inspect --format '{{index .Config.Labels "${IMAGE_LABEL}"}}' ${name} 2>/dev/null)" = ${image} ]`;
-    const bootScript = [
-      `. ${CONTAINER_ENV_PATH}`,
-      `mkdir -p ${shell(directory)}`,
-      `cd ${shell(directory)}`,
-      `exec ${runtimeCommand}`
-    ].join(" && ");
-    const mounts = [["workspace", directory], ...PERSISTENT_HOME_MOUNTS];
-    const run = `docker run -d --name ${containerName} --hostname ${shell(containerHostname(input.workspaceId))} -p ${port}:${port} -v ${VM_DOCKER_INIT}:${CONTAINER_INIT_PATH}:ro -v "$(pwd)/${RUNTIME_ENV_PATH}:${CONTAINER_ENV_PATH}:ro" --env-file ${trees}/${IMAGE_ENV_FILE} ` + IMAGE_TREES.map((tree) => `-v ${trees}/${tree}:/${tree} `).join("") + mounts.map(([source, target]) => `-v "$(pwd)/${PERSISTENT_ROOT}/${source}":${shell(target)} `).join("") + `${CONTAINER_SECURITY_OPTIONS} --entrypoint ${CONTAINER_INIT_PATH} ${STUB_IMAGE} -- sh -lc ${shell(bootScript)}`;
-    const seedTrees = `sudo rm -rf ${trees} && sudo mkdir -p ${trees} && { docker rm -f ${SEED_CONTAINER_NAME} >/dev/null 2>&1 || true; } && docker create --name ${SEED_CONTAINER_NAME} ${image} true >/dev/null && for tree in ${IMAGE_TREES.join(" ")}; do docker cp ${SEED_CONTAINER_NAME}:/$tree - | sudo tar -xf - -C ${trees} ${IMAGE_TREE_SEED_EXCLUDES.map((exclude) => `--exclude=${exclude}`).join(" ")} && [ -d ${trees}/$tree ] || exit 1; done && docker rm ${SEED_CONTAINER_NAME} >/dev/null && sudo touch ${trees}/${IMAGE_TREES_COMPLETE_MARKER}`;
-    const seedStub = `stub=$(mktemp -d) && docker image inspect --format '{{range .Config.Env}}{{println .}}{{end}}' ${image} > "$stub/${IMAGE_ENV_FILE}" && workdir=$(docker image inspect --format '{{or .Config.WorkingDir "/"}}' ${image}) && mkdir "$stub/root" ${ROOT_DIRECTORIES.map((directory2) => `"$stub/root/${directory2}"`).join(" ")} && ${ROOT_LINKS.map((link) => `ln -s usr/${link} "$stub/root/${link}"`).join(" && ")} && chmod 1777 "$stub/root/tmp" && tar --owner=0 --group=0 --numeric-owner -cf "$stub/skeleton.tar" -C "$stub/root" . && docker import --change "WORKDIR $workdir" --change ${shell(`LABEL ${IMAGE_LABEL}=${reference}`)} "$stub/skeleton.tar" ${STUB_IMAGE} >/dev/null && docker save -o "$stub/${STUB_IMAGE_ARCHIVE}" ${STUB_IMAGE} && sudo mv "$stub/${IMAGE_ENV_FILE}" "$stub/${STUB_IMAGE_ARCHIVE}" ${trees}/ && rm -rf "$stub"`;
-    const removeImage = `if docker image inspect ${image} >/dev/null 2>&1; then leftovers=$(docker ps -aq --filter ancestor=${image}) && { [ -z "$leftovers" ] || docker rm -f $leftovers >/dev/null; } && id=$(docker image inspect --format '{{.Id}}' ${image}) && docker rmi ${image} >/dev/null && sudo rm -f ${BOAT_SAVED_IMAGES}/"\${id#sha256:}".tar; fi`;
-    const seeded = [IMAGE_TREES_COMPLETE_MARKER, STUB_IMAGE_ARCHIVE, IMAGE_ENV_FILE].map((file) => `[ -f ${trees}/${file} ]`).join(" && ");
-    const prepare = [
-      `chmod 600 ${staged.env}`,
-      `find . -maxdepth 1 \\( -name '${RUNTIME_ENV_PATH}.*' -o -name '${REGISTRY_PASSWORD_PATH}.*' \\) -mmin +${BOOT_TTL_SECONDS / 60} -exec rm -f {} +`,
-      `timeout ${DOCKER_DAEMON_WAIT_SECONDS} sh -c 'until docker info >/dev/null 2>&1; do sleep 1; done'`,
-      `[ -x ${VM_DOCKER_INIT} ]`,
-      ...options.registryAuth && staged.password ? [`{ chmod 600 ${staged.password}; docker login ${shell(options.registryAuth.server)} --username ${shell(options.registryAuth.username)} --password-stdin < ${staged.password}; rc=$?; rm -f ${staged.password}; (exit $rc); }`] : [],
-      // Trees an earlier start marked complete hold what a person or a harness
-      // changed since, so a seed missing only its stub or env builds those alone.
-      `if ! { ${seeded}; }; then { docker image inspect ${image} >/dev/null 2>&1 || docker pull ${image} >/dev/null; } && { [ -f ${trees}/${IMAGE_TREES_COMPLETE_MARKER} ] || { ${seedTrees}; }; } && ${seedStub}; fi`,
-      `{ ${labelledWithImage("image", STUB_IMAGE)} || docker load -i ${trees}/${STUB_IMAGE_ARCHIVE} >/dev/null; }`,
-      `sudo find "$(pwd)/${PERSISTENT_ROOT}" -mindepth 1 -maxdepth 1 -name 'image-*' ! -path ${trees} -exec rm -rf {} +`
-    ];
-    const start = `mv -f ${staged.env} ${RUNTIME_ENV_PATH} && up=; for attempt in $(seq ${CONTAINER_CREATE_ATTEMPTS}); do [ "$attempt" = 1 ] || sleep 1; if ${labelledWithImage("container", containerName)}; then failure=$(docker start ${containerName} 2>&1 >/dev/null) && { up=1; break; }; else docker rm -f ${containerName} >/dev/null 2>&1; failure=$(${run} 2>&1 >/dev/null) && { up=1; break; }; fi; case "$failure" in *${shell(DOCKER_NAME_IN_USE)}*) ;; *) break ;; esac; done; [ -n "$up" ] || { echo "$failure" >&2; false; } && ${removeImage}`;
-    return {
-      prepare: holdingBootLock(IMAGE_PREPARATION_TIMEOUT_SECONDS, prepare.join(" && ")),
-      start: holdingBootLock(CONTAINER_START_TIMEOUT_SECONDS, start)
-    };
-  }
   function healthProbe(port, windowSeconds) {
     const booting = [...BOOTING_CONTAINER_STATES].join("|");
     return `end=$(($(date +%s) + ${windowSeconds})); while :; do code=$(curl -s -o /dev/null -w '%{http_code}' http://127.0.0.1:${port}/global/health); [ "$code" = 200 ] && break; state=$(docker inspect --format '{{.State.Status}}' ${shell(containerName)} 2>/dev/null || echo missing); case "$state" in ${booting}) ;; *) break ;; esac; [ "$(date +%s)" -lt "$end" ] || break; sleep ${healthIntervalMs / 1e3}; done; echo "$code"; echo "$state"`;
@@ -820,22 +841,41 @@ ${result.stderr}`, secrets), STDERR_TAIL_CHARS);
     }
     throw new SandboxRuntimeBootError(`Boat ${sandboxId} runtime did not become healthy: ${last}; ${diagnostic}`);
   }
-  async function startContainer(sandboxId, input, hostId) {
+  async function startContainer(sandboxId, input, hostId, keepPreviousImage) {
     const env = { ...bootEnv(input, hostId), ...await options.env?.(input, { id: hostId }) };
     const boot2 = crypto.randomUUID();
     const staged = {
       env: `${RUNTIME_ENV_PATH}.${boot2}`,
       ...options.registryAuth ? { password: `${REGISTRY_PASSWORD_PATH}.${boot2}` } : {}
     };
-    const scripts = containerScripts(input, staged);
+    const image = resolveImage(input);
+    const scripts = machineBootScripts({
+      image,
+      keepPreviousImage: keepPreviousImage && image === options.image,
+      workspaceId: input.workspaceId,
+      directory: workspaceDirectory(input),
+      port: runtimePort(input),
+      runtimeCommand,
+      containerName,
+      ...options.registryAuth ? { registry: { server: options.registryAuth.server, username: options.registryAuth.username } } : {},
+      staged,
+      staleStagedMinutes: BOOT_TTL_SECONDS / 60
+    });
     await client.writeFile(sandboxId, { path: staged.env, content: envFile(env) });
     if (options.registryAuth && staged.password) {
       await client.writeFile(sandboxId, { path: staged.password, content: options.registryAuth.password });
     }
     const secrets = [...workspaceRuntimeBootSecrets(env), ...options.registryAuth ? [options.registryAuth.password] : []];
     let failure;
+    let booted;
     try {
-      await execOrThrow(sandboxId, scripts.prepare, "runtime image preparation", { timeoutSeconds: IMAGE_PREPARATION_TIMEOUT_SECONDS, secrets });
+      const prepared = await execOrThrow(sandboxId, scripts.prepare, "runtime image preparation", { timeoutSeconds: IMAGE_PREPARATION_TIMEOUT_SECONDS, secrets }).catch((error) => {
+        throw error instanceof BoatDriverError && error.message.includes(IMAGE_DOWNLOAD_INTERRUPTED) ? new SandboxImageDownloadError(error.message) : error;
+      });
+      booted = bootedImage(prepared.stdout);
+      if (!booted) throw new BoatDriverError(`Boat ${sandboxId} runtime image preparation named no image it booted`);
+      const skipped = keepPreviousImage ? prepared.stderr.split("\n").find((line) => line.startsWith(KEPT_IMAGE_SKIPPED)) : void 0;
+      if (skipped) console.warn("A Boat wake took the deployment's image instead of the one the machine last booted", { sandboxId, workspaceId: input.workspaceId, found: skipped.slice(KEPT_IMAGE_SKIPPED.length).trim() });
       try {
         await execOrThrow(sandboxId, scripts.start, "container start", { timeoutSeconds: CONTAINER_START_TIMEOUT_SECONDS, secrets });
       } catch (error) {
@@ -846,19 +886,19 @@ ${result.stderr}`, secrets), STDERR_TAIL_CHARS);
     }
     try {
       if (options.registryAuth || failure !== void 0) {
-        await execOrThrow(sandboxId, `rm -f ${[staged.env, staged.password].filter(Boolean).join(" ")}`, "staged file cleanup", { secrets });
+        await execOrThrow(sandboxId, `rm -f ${[staged.env, staged.password, bootedImageFile(staged)].filter(Boolean).join(" ")}`, "staged file cleanup", { secrets });
       }
     } catch (cleanupFailure) {
       if (failure === void 0) throw cleanupFailure;
       if (failure instanceof Error) failure.message = `${failure.message}; ${cleanupFailure instanceof Error ? cleanupFailure.message : String(cleanupFailure)}`;
     }
-    if (failure !== void 0) throw failure;
-    return secrets;
+    if (failure !== void 0 || !booted) throw failure;
+    return { secrets, booted };
   }
-  async function boot(sandboxId, input, hostId) {
+  async function boot(sandboxId, input, hostId, keepPreviousImage) {
     await input.onMachineReady?.();
     const port = runtimePort(input);
-    const secrets = await startContainer(sandboxId, input, hostId);
+    const { secrets, booted } = await startContainer(sandboxId, input, hostId, keepPreviousImage);
     await input.onImageReady?.();
     await execOrThrow(sandboxId, holdingBootLock(HOST_PUBLISH_TIMEOUT_SECONDS, `host ${port} --public`), "host publish", {
       timeoutSeconds: HOST_PUBLISH_TIMEOUT_SECONDS,
@@ -878,7 +918,7 @@ ${result.stderr}`, secrets), STDERR_TAIL_CHARS);
       hostId,
       driverResourceId: sandboxId,
       driver: { id: "boat", resourceId: sandboxId },
-      labels: { ...input.labels, ...resolveImage(input) === options.image ? { [SANDBOX_IMAGE_LABEL]: options.image } : {} }
+      labels: { ...input.labels, ...resolveImage(input) === options.image ? { [SANDBOX_IMAGE_LABEL]: booted } : {} }
     };
   }
   function assertNetwork(input) {
@@ -927,7 +967,7 @@ ${result.stderr}`, secrets), STDERR_TAIL_CHARS);
     if (failures.length > 1) throw new AggregateError(failures, `Boat ${created.id} resource handoff and deletion failed`);
     const ready = await waitUntilReady(created.id);
     if (!ready) return { provisioning: true, retryAfterMs: 0 };
-    return boot(created.id, input, hostId);
+    return boot(created.id, input, hostId, false);
   }
   async function resumeHost(input) {
     const sandboxId = input.lease.sandboxId;
@@ -947,7 +987,7 @@ ${result.stderr}`, secrets), STDERR_TAIL_CHARS);
     }
     const ready = await waitUntilReady(sandboxId);
     if (!ready) return { provisioning: true, retryAfterMs: 0 };
-    return boot(sandboxId, input.ensure, hostId);
+    return boot(sandboxId, input.ensure, hostId, !input.ensure.updateImage);
   }
   async function stop(target) {
     await client.command(target.sandboxId, {
@@ -983,7 +1023,6 @@ ${result.stderr}`, secrets), STDERR_TAIL_CHARS);
   };
 }
 export {
-  boatTemplateResetCommand,
   createBoatSandboxDriver,
   formatBoatRuntimeTemplate,
   parseBoatRuntimeTemplate

package/dist/drivers/cloudflare.mjs

@@ -31,7 +31,7 @@ var cloudflareBilling = {
 };
 
 // ../sandbox-contract/dist/index.mjs
-var sandboxCheckpointUnusableCauses = ["expired", "runtime_outdated", "runtime_modified", "not_restorable"];
+var sandboxCheckpointUnusableCauses = ["expired", "runtime_modified", "not_restorable"];
 function isSandboxCheckpointUnusableCause(value) {
   return sandboxCheckpointUnusableCauses.some((cause) => cause === value);
 }
@@ -311,7 +311,11 @@ function workspaceRuntimeSourceEnv(input) {
 }
 
 // src/runtime-version.ts
-var MINIMUM_RESTORABLE_WORKSPACE_RUNTIME_VERSION = "0.5.2";
+var SERVED_WORKSPACE_RUNTIME_FLOOR = {
+  version: "0.10.1",
+  image: "ghcr.io/kyashrathore/claxedo-sandbox:workspace-runtime-0-10-1-40706b7356-agent-plugins-v8"
+};
+var MINIMUM_SERVED_WORKSPACE_RUNTIME_VERSION = SERVED_WORKSPACE_RUNTIME_FLOOR.version;
 
 // src/drivers/cloudflare.ts
 function registryEntries(input) {
@@ -452,7 +456,7 @@ function createCloudflareSandboxDriver(options) {
         // what makes this driver's `list()` (and therefore GC) possible at all.
         // Not container env — labels are control-plane metadata.
         labels: input.labels,
-        ...input.bootSource?.kind === "driver-snapshot" ? { restore: { snapshotId: input.bootSource.snapshotId }, minimumRuntimeVersion: MINIMUM_RESTORABLE_WORKSPACE_RUNTIME_VERSION } : {},
+        ...input.bootSource?.kind === "driver-snapshot" ? { restore: { snapshotId: input.bootSource.snapshotId }, minimumRuntimeVersion: MINIMUM_SERVED_WORKSPACE_RUNTIME_VERSION } : {},
         ...egress ? { egress } : {}
       }
     ).catch((error) => {

package/dist/drivers/docker.mjs

@@ -91,6 +91,11 @@ var DEFAULT_WORKSPACE_RUNTIME_VERSION = "0.5.2";
 function workspaceRuntimeVersion() {
   return process.env.WORKSPACE_RUNTIME_VERSION || DEFAULT_WORKSPACE_RUNTIME_VERSION;
 }
+var SERVED_WORKSPACE_RUNTIME_FLOOR = {
+  version: "0.10.1",
+  image: "ghcr.io/kyashrathore/claxedo-sandbox:workspace-runtime-0-10-1-40706b7356-agent-plugins-v8"
+};
+var MINIMUM_SERVED_WORKSPACE_RUNTIME_VERSION = SERVED_WORKSPACE_RUNTIME_FLOOR.version;
 
 // src/image-name.ts
 var SNAPSHOT_SCHEMA_VERSION = 8;

package/dist/drivers/local-brokering.d.ts

@@ -1,9 +1,21 @@
 import type { SandboxDriver } from "../contract";
 import { localBrokeringTestDriverCatalogEntry } from "../driver-catalog";
+/**
+ * A published runtime image to run instead of `executable`: Docker on the host
+ * network, with the paths the runtime reads mounted where they are, and no
+ * sandbox-exec network policy, so it runs on Linux. The version-skew suite
+ * runs the control plane against the oldest image it still serves this way.
+ */
+export type LocalBrokeringContainer = {
+    image: string;
+    command: string;
+    mounts: readonly string[];
+};
 export type LocalBrokeringDriverOptions = {
     root: string;
     executable: string;
     args: string[];
+    container?: LocalBrokeringContainer;
     allowedOrigins: readonly string[];
     directOrigins: readonly string[];
     upstreams?: Readonly<Record<string, string>>;

package/dist/drivers/local-brokering.mjs

@@ -793,6 +793,7 @@ ${lines}` : ""}`);
 }
 async function closeHost(host) {
   const child = host.child;
+  if (host.container) execFileSync("docker", ["rm", "-f", host.container], { stdio: "ignore" });
   if (child && child.exitCode === null) {
     child.kill("SIGTERM");
     await new Promise((resolve) => child.once("exit", () => resolve()));
@@ -802,8 +803,14 @@ async function closeHost(host) {
   await new Promise((resolve) => host.proxy.close(() => resolve()));
   await fs.rm(host.directory, { recursive: true, force: true });
 }
+function containerRun(container, name, input) {
+  const user = `${process.getuid?.() ?? 0}:${process.getgid?.() ?? 0}`;
+  const mounts = [.../* @__PURE__ */ new Set([input.root, ...container.mounts])].flatMap((mount) => ["-v", `${mount}:${mount}`]);
+  const env = Object.keys(input.env).filter((key) => key !== "PATH").flatMap((key) => ["-e", key]);
+  return { name, args: ["run", "--rm", "--name", name, "--network", "host", "--user", user, ...mounts, ...env, "-w", input.workspace, "--entrypoint", container.command, container.image] };
+}
 function createLocalBrokeringSandboxDriver(options) {
-  if (process.platform !== "darwin") throw new Error("local brokering test driver requires macOS sandbox-exec network policy");
+  if (process.platform !== "darwin" && !options.container) throw new Error("local brokering test driver requires macOS sandbox-exec network policy, or a runtime container");
   const authority = createTestAuthority(options.root);
   const hosts = /* @__PURE__ */ new Map();
   const allowedOrigins = new Set(options.allowedOrigins.map((origin) => new URL(origin).origin));
@@ -976,11 +983,9 @@ function createLocalBrokeringSandboxDriver(options) {
       const log = openSync(logFile, "w", 384);
       let child;
       try {
-        child = spawn("/usr/bin/sandbox-exec", ["-p", networkPolicy, options.executable, ...options.args], {
-          cwd: workspace,
-          env,
-          stdio: ["ignore", log, log]
-        });
+        const container = options.container ? containerRun(options.container, `claxedo-local-${target.sandboxId}`, { root: options.root, workspace, env }) : void 0;
+        if (container) host.container = container.name;
+        child = container ? spawn("docker", container.args, { env: { ...process.env, ...env }, stdio: ["ignore", log, log] }) : spawn("/usr/bin/sandbox-exec", ["-p", networkPolicy, options.executable, ...options.args], { cwd: workspace, env, stdio: ["ignore", log, log] });
       } finally {
         closeSync(log);
       }

package/dist/drivers/modal.mjs

@@ -73,6 +73,11 @@ var DEFAULT_WORKSPACE_RUNTIME_VERSION = "0.5.2";
 function workspaceRuntimeVersion() {
   return process.env.WORKSPACE_RUNTIME_VERSION || DEFAULT_WORKSPACE_RUNTIME_VERSION;
 }
+var SERVED_WORKSPACE_RUNTIME_FLOOR = {
+  version: "0.10.1",
+  image: "ghcr.io/kyashrathore/claxedo-sandbox:workspace-runtime-0-10-1-40706b7356-agent-plugins-v8"
+};
+var MINIMUM_SERVED_WORKSPACE_RUNTIME_VERSION = SERVED_WORKSPACE_RUNTIME_FLOOR.version;
 
 // src/image-name.ts
 var SNAPSHOT_SCHEMA_VERSION = 8;

package/dist/drivers/vercel.mjs

@@ -73,6 +73,11 @@ var DEFAULT_WORKSPACE_RUNTIME_VERSION = "0.5.2";
 function workspaceRuntimeVersion() {
   return process.env.WORKSPACE_RUNTIME_VERSION || DEFAULT_WORKSPACE_RUNTIME_VERSION;
 }
+var SERVED_WORKSPACE_RUNTIME_FLOOR = {
+  version: "0.10.1",
+  image: "ghcr.io/kyashrathore/claxedo-sandbox:workspace-runtime-0-10-1-40706b7356-agent-plugins-v8"
+};
+var MINIMUM_SERVED_WORKSPACE_RUNTIME_VERSION = SERVED_WORKSPACE_RUNTIME_FLOOR.version;
 
 // src/command.ts
 function shell(input) {

package/dist/image-name.mjs

@@ -3,6 +3,11 @@ var DEFAULT_WORKSPACE_RUNTIME_VERSION = "0.5.2";
 function workspaceRuntimeVersion() {
   return process.env.WORKSPACE_RUNTIME_VERSION || DEFAULT_WORKSPACE_RUNTIME_VERSION;
 }
+var SERVED_WORKSPACE_RUNTIME_FLOOR = {
+  version: "0.10.1",
+  image: "ghcr.io/kyashrathore/claxedo-sandbox:workspace-runtime-0-10-1-40706b7356-agent-plugins-v8"
+};
+var MINIMUM_SERVED_WORKSPACE_RUNTIME_VERSION = SERVED_WORKSPACE_RUNTIME_FLOOR.version;
 
 // src/image-name.ts
 var SNAPSHOT_SCHEMA_VERSION = 8;

package/dist/image.d.ts

@@ -1,4 +1,5 @@
 export { RUNTIME_DIR, WORKSPACE_RUNTIME_PORT, WORKSPACE_DIR } from "./defaults";
 export { SNAPSHOT_SCHEMA_VERSION, snapshotVersion, assertSandboxImageReference, defaultSandboxImage, } from "./image-name";
+export { SERVED_WORKSPACE_RUNTIME_FLOOR } from "./runtime-version";
 export declare const SANDBOX_IMAGE_REPOSITORY: string;
 export declare const SANDBOX_IMAGE: string;

package/dist/image.mjs

@@ -11,6 +11,11 @@ var DEFAULT_WORKSPACE_RUNTIME_VERSION = "0.5.2";
 function workspaceRuntimeVersion() {
   return process.env.WORKSPACE_RUNTIME_VERSION || DEFAULT_WORKSPACE_RUNTIME_VERSION;
 }
+var SERVED_WORKSPACE_RUNTIME_FLOOR = {
+  version: "0.10.1",
+  image: "ghcr.io/kyashrathore/claxedo-sandbox:workspace-runtime-0-10-1-40706b7356-agent-plugins-v8"
+};
+var MINIMUM_SERVED_WORKSPACE_RUNTIME_VERSION = SERVED_WORKSPACE_RUNTIME_FLOOR.version;
 
 // src/image-name.ts
 var SNAPSHOT_SCHEMA_VERSION = 8;
@@ -45,6 +50,7 @@ export {
   RUNTIME_DIR,
   SANDBOX_IMAGE,
   SANDBOX_IMAGE_REPOSITORY,
+  SERVED_WORKSPACE_RUNTIME_FLOOR,
   SNAPSHOT_SCHEMA_VERSION,
   WORKSPACE_DIR,
   WORKSPACE_RUNTIME_PORT,