@elench/testkit 0.1.150 → 0.1.151

package/lib/database/local-postgres.mjs

@@ -10,18 +10,30 @@ import {
   LOCAL_READY_TIMEOUT_MS,
   LOCAL_USER,
 } from "./constants.mjs";
-import { buildContainerName } from "./naming.mjs";
+import { buildContainerName, buildVolumeName } from "./naming.mjs";
 import { getLocalInfraDir, readStateValue } from "./state.mjs";
-import { buildDockerResourceLabels, dockerLabelArgs } from "../ownership/docker.mjs";
+import {
+  buildDockerResourceLabels,
+  dockerLabelArgs,
+  inspectDockerVolume,
+  removeDockerVolume,
+} from "../ownership/docker.mjs";
 import { writeLocalInfraState } from "./state-files.mjs";
 
+const LEGACY_POSTGRES_DATA_VOLUME_TARGET = "/var/lib/postgresql/data";
+const POSTGRES_18_VOLUME_TARGET = "/var/lib/postgresql";
+
 export async function ensureLocalContainer(productDir, database = {}) {
   const infraDir = getLocalInfraDir(productDir);
   fs.mkdirSync(infraDir, { recursive: true });
 
   const containerName =
     readStateValue(path.join(infraDir, "container_name")) || buildContainerName(productDir);
+  const volumeName =
+    readStateValue(path.join(infraDir, "volume_name")) || buildVolumeName(productDir);
   const image = database.image || readStateValue(path.join(infraDir, "image")) || LOCAL_IMAGE;
+  const previousImage = readStateValue(path.join(infraDir, "image"));
+  const volumeMountPath = resolveLocalPostgresVolumeTarget(image);
   const user = database.user || readStateValue(path.join(infraDir, "user")) || LOCAL_USER;
   const password =
     database.password || readStateValue(path.join(infraDir, "password")) || LOCAL_PASSWORD;
@@ -32,13 +44,21 @@ export async function ensureLocalContainer(productDir, database = {}) {
   let inspect = await inspectContainer(containerName);
   if (
     inspect &&
-    (inspect.Config?.Image !== image || !containerUsesMaxConnections(inspect, maxConnections))
+    (
+      inspect.Config?.Image !== image ||
+      !containerUsesMaxConnections(inspect, maxConnections) ||
+      !containerUsesNamedVolume(inspect, volumeName, volumeMountPath)
+    )
   ) {
     await stopAndRemoveContainer(containerName);
+    if (previousImage && previousImage !== image) {
+      await removeOwnedLocalPostgresVolume(productDir, volumeName);
+    }
     inspect = null;
   }
 
   if (!inspect) {
+    await ensureLocalPostgresVolume(productDir, volumeName);
     const labels = buildLocalPostgresContainerLabels(productDir, containerName);
     await execa("docker", [
       "run",
@@ -46,6 +66,8 @@ export async function ensureLocalContainer(productDir, database = {}) {
       "--name",
       containerName,
       ...dockerLabelArgs(labels),
+      "--mount",
+      `type=volume,source=${volumeName},target=${volumeMountPath}`,
       "-e",
       `POSTGRES_USER=${user}`,
       "-e",
@@ -73,6 +95,8 @@ export async function ensureLocalContainer(productDir, database = {}) {
   const infra = {
     containerName,
     containerId: inspect.Id,
+    volumeName,
+    volumeMountPath,
     image,
     user,
     password,
@@ -90,6 +114,7 @@ export async function loadExistingLocalContainer(productDir) {
   const infraDir = getLocalInfraDir(productDir);
   const containerName = readStateValue(path.join(infraDir, "container_name"));
   if (!containerName) return null;
+  const volumeName = readStateValue(path.join(infraDir, "volume_name")) || buildVolumeName(productDir);
 
   const inspect = await inspectContainer(containerName);
   if (!inspect) return null;
@@ -105,6 +130,9 @@ export async function loadExistingLocalContainer(productDir) {
   const infra = {
     containerName,
     containerId: nextInspect.Id,
+    volumeName,
+    volumeMountPath: readStateValue(path.join(infraDir, "volume_mount_path")) ||
+      resolveLocalPostgresVolumeTarget(nextInspect.Config?.Image || readStateValue(path.join(infraDir, "image")) || LOCAL_IMAGE),
     image: nextInspect.Config?.Image || readStateValue(path.join(infraDir, "image")) || LOCAL_IMAGE,
     user: readStateValue(path.join(infraDir, "user")) || LOCAL_USER,
     password: readStateValue(path.join(infraDir, "password")) || LOCAL_PASSWORD,
@@ -124,6 +152,15 @@ function containerUsesMaxConnections(inspect, maxConnections) {
   return cmd.join(" ") === `postgres -c max_connections=${maxConnections}`;
 }
 
+function containerUsesNamedVolume(inspect, volumeName, volumeMountPath) {
+  const mounts = Array.isArray(inspect?.Mounts) ? inspect.Mounts : [];
+  return mounts.some((mount) =>
+    mount?.Type === "volume" &&
+    mount?.Name === volumeName &&
+    mount?.Destination === volumeMountPath
+  );
+}
+
 function normalizeMaxConnections(value) {
   const number = Number(value);
   if (!Number.isInteger(number) || number < 10) {
@@ -144,12 +181,57 @@ export async function inspectContainer(containerName) {
 
 export async function stopAndRemoveContainer(containerName) {
   try {
-    await execa("docker", ["rm", "-f", containerName]);
+    await execa("docker", ["rm", "-f", "-v", containerName]);
   } catch {
     // Already gone.
   }
 }
 
+async function ensureLocalPostgresVolume(productDir, volumeName) {
+  const labels = buildLocalPostgresVolumeLabels(productDir, volumeName);
+  const existing = await inspectDockerVolume(volumeName);
+  if (existing) {
+    const existingLabels = existing.Labels || {};
+    const mismatched = Object.entries(labels).some(([key, value]) => existingLabels[key] !== String(value));
+    if (mismatched) {
+      throw new Error(
+        `Docker volume ${volumeName} already exists but is not owned by this Testkit product. ` +
+        `Remove or rename it before running Testkit.`
+      );
+    }
+    return;
+  }
+  await execa("docker", [
+    "volume",
+    "create",
+    ...dockerLabelArgs(labels),
+    volumeName,
+  ]);
+}
+
+async function removeOwnedLocalPostgresVolume(productDir, volumeName) {
+  const labels = buildLocalPostgresVolumeLabels(productDir, volumeName);
+  const existing = await inspectDockerVolume(volumeName);
+  if (!existing) return;
+  const existingLabels = existing.Labels || {};
+  const ownedByThisProduct = Object.entries(labels).every(([key, value]) => existingLabels[key] === String(value));
+  if (!ownedByThisProduct) return;
+  await removeDockerVolume(volumeName);
+}
+
+export function resolveLocalPostgresVolumeTarget(image) {
+  return postgresImageMajorVersion(image) >= 18
+    ? POSTGRES_18_VOLUME_TARGET
+    : LEGACY_POSTGRES_DATA_VOLUME_TARGET;
+}
+
+function postgresImageMajorVersion(image) {
+  const text = String(image || "");
+  const match = text.match(/(?:^|[:@/-])(?:pg|postgres)?(\d{2})(?:\D|$)/i);
+  if (!match) return 16;
+  return Number(match[1]);
+}
+
 async function waitForLocalContainerReady(infra) {
   const startedAt = Date.now();
   while (Date.now() - startedAt < LOCAL_READY_TIMEOUT_MS) {
@@ -181,6 +263,15 @@ function buildLocalPostgresContainerLabels(productDir, containerName) {
   });
 }
 
+function buildLocalPostgresVolumeLabels(productDir, volumeName) {
+  return buildDockerResourceLabels(productDir, {
+    kind: "postgres-volume",
+    name: volumeName,
+    scope: "local-postgres",
+    cachePolicy: "product-cache",
+  });
+}
+
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/lib/database/naming.mjs

@@ -13,6 +13,13 @@ export function buildContainerName(productDir) {
   );
 }
 
+export function buildVolumeName(productDir) {
+  return limitIdentifier(
+    `testkit_pgdata_${slugSegment(path.basename(productDir))}_${hashString(productDir, 10)}`,
+    63
+  );
+}
+
 export function buildTemplateDatabaseName(serviceName, fingerprint) {
   return limitIdentifier(
     `tk_tpl_${slugSegment(serviceName)}_${fingerprint.slice(0, 16)}`,

package/lib/database/state-files.mjs

@@ -8,6 +8,12 @@ export function writeLocalInfraState(infraDir, infra) {
   fs.writeFileSync(path.join(infraDir, "database_backend"), "local");
   fs.writeFileSync(path.join(infraDir, "container_name"), infra.containerName);
   fs.writeFileSync(path.join(infraDir, "container_id"), infra.containerId);
+  if (infra.volumeName) {
+    fs.writeFileSync(path.join(infraDir, "volume_name"), infra.volumeName);
+  }
+  if (infra.volumeMountPath) {
+    fs.writeFileSync(path.join(infraDir, "volume_mount_path"), infra.volumeMountPath);
+  }
   fs.writeFileSync(path.join(infraDir, "ownership_product_id"), product.id);
   fs.writeFileSync(path.join(infraDir, "image"), infra.image);
   fs.writeFileSync(path.join(infraDir, "user"), infra.user);
@@ -24,6 +30,12 @@ export function writeCacheState(cacheDir, config, infra, templateDbName, fingerp
   fs.writeFileSync(path.join(cacheDir, "template_fingerprint"), fingerprint);
   if (backend === "local") {
     fs.writeFileSync(path.join(cacheDir, "container_name"), infra.containerName);
+    if (infra.volumeName) {
+      fs.writeFileSync(path.join(cacheDir, "volume_name"), infra.volumeName);
+    }
+    if (infra.volumeMountPath) {
+      fs.writeFileSync(path.join(cacheDir, "volume_mount_path"), infra.volumeMountPath);
+    }
   } else {
     fs.writeFileSync(path.join(cacheDir, "resource_name"), infra.resourceName);
     writeResourceConnectionState(cacheDir, infra);

package/lib/docker-compat/matrix.mjs

@@ -77,7 +77,7 @@ export function buildDockerCompatProbeCommand(entry, options = {}) {
     "done",
     "actual=$(docker version --format '{{.Server.Version}}')",
     `case "$actual" in ${shellCasePattern(normalized.dockerVersion)}*) ;; *) echo "expected Docker ${normalized.dockerVersion}, got $actual" >&2; exit 1 ;; esac`,
-    `docker rm -f ${shellQuote(containerName)} >/dev/null 2>&1 || true`,
+    `docker rm -f -v ${shellQuote(containerName)} >/dev/null 2>&1 || true`,
     [
       "docker run -d",
       "--name",
@@ -90,20 +90,22 @@ export function buildDockerCompatProbeCommand(entry, options = {}) {
       "POSTGRES_DB=postgres",
       "-p",
       "127.0.0.1::5432",
+      "--tmpfs",
+      "/var/lib/postgresql/data:rw",
       shellQuote(postgresImage),
     ].join(" "),
     "ready_deadline=$(($(date +%s) + 120))",
     "until docker exec " + shellQuote(containerName) + " pg_isready -U testkit -d postgres >/dev/null 2>&1; do",
     "  if [ \"$(date +%s)\" -ge \"$ready_deadline\" ]; then",
     "    docker logs " + shellQuote(containerName) + " >&2 || true",
-    "    docker rm -f " + shellQuote(containerName) + " >/dev/null 2>&1 || true",
+    "    docker rm -f -v " + shellQuote(containerName) + " >/dev/null 2>&1 || true",
     "    exit 1",
     "  fi",
     "  sleep 1",
     "done",
     "published_port=$(docker inspect --format '{{(index (index .NetworkSettings.Ports \"5432/tcp\") 0).HostPort}}' " + shellQuote(containerName) + ")",
     "test -n \"$published_port\"",
-    "docker rm -f " + shellQuote(containerName) + " >/dev/null",
+    "docker rm -f -v " + shellQuote(containerName) + " >/dev/null",
     "echo \"Docker $actual compatibility probe passed\"",
   ].join("\n");
 }

package/lib/kiln/client.mjs

@@ -92,6 +92,14 @@ export class KilnClient {
     return this.request("DELETE", `/appliances/${encodeURIComponent(ref)}`);
   }
 
+  diskUsage() {
+    return this.request("GET", "/disk/usage");
+  }
+
+  cleanup(req = {}) {
+    return this.request("POST", "/cleanup", req);
+  }
+
   sshKey(machineId) {
     return this.requestRaw("GET", `/machines/${encodeURIComponent(machineId)}/ssh-key`);
   }

package/lib/local/kiln-driver.mjs

@@ -112,12 +112,16 @@ export async function kilnLocalDown(context, name, options = {}) {
   const manifest = readLocalEnvironmentManifest(context.productDir, name);
   if (!manifest) return null;
   if (!manifest.kiln?.vm?.name) {
-    writeKilnManifest(context.productDir, name, {
-      ...manifest,
-      status: "stopped",
-      stoppedAt: new Date().toISOString(),
-      services: [],
-    });
+    if (options.destroyState) {
+      removeKilnEnvironmentState(context.productDir, name);
+    } else {
+      writeKilnManifest(context.productDir, name, {
+        ...manifest,
+        status: "stopped",
+        stoppedAt: new Date().toISOString(),
+        services: [],
+      });
+    }
     return manifest;
   }
   const ssh = await sshFromManifest(manifest);
@@ -132,14 +136,17 @@ export async function kilnLocalDown(context, name, options = {}) {
     if (result.exitCode !== 0) {
       throw new Error(`remote testkit local down failed\n${result.stdout}${result.stderr}`);
     }
-    writeKilnManifest(context.productDir, name, {
-      ...manifest,
-      status: "stopped",
-      stoppedAt: new Date().toISOString(),
-      services: [],
-    });
     if (options.destroyState) {
-      await deleteManifestResources(manifest);
+      await deleteManifestResources(manifest, { includeEnvironmentVM: true });
+      await cleanupKilnOrphans(manifest);
+      removeKilnEnvironmentState(context.productDir, name);
+    } else {
+      writeKilnManifest(context.productDir, name, {
+        ...manifest,
+        status: "stopped",
+        stoppedAt: new Date().toISOString(),
+        services: [],
+      });
     }
     return manifest;
   } finally {
@@ -250,16 +257,16 @@ async function attachExistingVMs(client, network, vmRefs) {
 }
 
 async function ensureResources(client, environment, network) {
-	const configured = flattenEnvironmentResources(environment.resources || {});
-	const manifest = {};
-	const connections = {};
-	for (const [name, resource] of Object.entries(configured)) {
-		if (resource.kind === "postgres") {
-			const appliance = await client.ensureAppliance(buildPostgresApplianceRequest(name, resource, environment, network));
-			manifest[name] = pickAppliance(appliance);
-			connections[name] = appliance.connection || {};
-			continue;
-		}
+  const configured = flattenEnvironmentResources(environment.resources || {});
+  const manifest = {};
+  const connections = {};
+  for (const [name, resource] of Object.entries(configured)) {
+    if (resource.kind === "postgres") {
+      const appliance = await client.ensureAppliance(buildPostgresApplianceRequest(name, resource, environment, network));
+      manifest[name] = pickAppliance(appliance);
+      connections[name] = appliance.connection || {};
+      continue;
+    }
     if (resource.kind === "server") {
       const appliance = await client.ensureAppliance({
         name: resource.vm?.name || `${environment.name}-${name}`,
@@ -279,7 +286,7 @@ async function ensureResources(client, environment, network) {
       connections[name] = appliance.connection || {};
     }
   }
-	return { manifest, connections };
+  return { manifest, connections };
 }
 
 export function flattenEnvironmentResources(resources = {}) {
@@ -290,69 +297,89 @@ export function flattenEnvironmentResources(resources = {}) {
 }
 
 export function buildPostgresApplianceRequest(name, resource, environment, network) {
-	const extensions = normalizePostgresExtensions(resource.extensions);
-	const image = resolvePostgresResourceImage(resource, name);
-	return {
-		name: resource.vm?.name || `${environment.name}-${name}`,
-		kind: "postgres",
-		network_id: resource.vm?.networkId || network?.id || "",
-		profile: resource.vm?.profile || "ubuntu-docker",
-		disk_size_mb: parseDiskMB(resource.vm?.disk || resource.vm?.diskSize || resource.vm?.diskSizeMB || resource.disk || "24G"),
-		memory_mb: Number(resource.vm?.memoryMB || resource.memoryMB || 1536),
-		vcpus: Number(resource.vm?.vcpus || resource.vcpus || 1),
-		autostart: Boolean(resource.vm?.autostart || resource.autostart),
-		postgres: {
-			version: resource.version || "16",
-			...(image ? { image } : {}),
-			database: resource.database || name,
-			user: resource.user || "app",
-			...(resource.password ? { password: resource.password } : {}),
-			...(resource.port ? { port: Number(resource.port) } : {}),
-			...(resource.maxConnections ? { max_connections: Number(resource.maxConnections) } : {}),
-		},
-		metadata: {
-			"testkit.environment": environment.name,
-			"testkit.resource": name,
-			...(extensions.length > 0 ? { "testkit.postgres.extensions": extensions.join(",") } : {}),
-		},
-	};
+  const extensions = normalizePostgresExtensions(resource.extensions);
+  const image = resolvePostgresResourceImage(resource, name);
+  return {
+    name: resource.vm?.name || `${environment.name}-${name}`,
+    kind: "postgres",
+    network_id: resource.vm?.networkId || network?.id || "",
+    profile: resource.vm?.profile || "ubuntu-docker",
+    disk_size_mb: parseDiskMB(resource.vm?.disk || resource.vm?.diskSize || resource.vm?.diskSizeMB || resource.disk || "24G"),
+    memory_mb: Number(resource.vm?.memoryMB || resource.memoryMB || 1536),
+    vcpus: Number(resource.vm?.vcpus || resource.vcpus || 1),
+    autostart: Boolean(resource.vm?.autostart || resource.autostart),
+    postgres: {
+      version: resource.version || "16",
+      ...(image ? { image } : {}),
+      database: resource.database || name,
+      user: resource.user || "app",
+      ...(resource.password ? { password: resource.password } : {}),
+      ...(resource.port ? { port: Number(resource.port) } : {}),
+      ...(resource.maxConnections ? { max_connections: Number(resource.maxConnections) } : {}),
+    },
+    metadata: {
+      "testkit.environment": environment.name,
+      "testkit.resource": name,
+      ...(extensions.length > 0 ? { "testkit.postgres.extensions": extensions.join(",") } : {}),
+    },
+  };
 }
 
 export function resolvePostgresResourceImage(resource, resourceName = "postgres") {
-	if (resource.image) return resource.image;
-	const extensions = normalizePostgresExtensions(resource.extensions);
-	if (extensions.length === 0) return null;
-	const unsupported = extensions.filter((extension) => extension !== "vector" && extension !== "pgvector");
-	if (unsupported.length > 0) {
-		throw new Error(
-			`Postgres resource "${resourceName}" requests unsupported extensions: ${unsupported.join(", ")}. ` +
-				`Set resource.postgres({ image }) to provide a custom Postgres image.`
-		);
-	}
-	return `pgvector/pgvector:pg${postgresMajorVersion(resource.version || "16")}-trixie`;
+  if (resource.image) return resource.image;
+  const extensions = normalizePostgresExtensions(resource.extensions);
+  if (extensions.length === 0) return null;
+  const unsupported = extensions.filter((extension) => extension !== "vector" && extension !== "pgvector");
+  if (unsupported.length > 0) {
+    throw new Error(
+      `Postgres resource "${resourceName}" requests unsupported extensions: ${unsupported.join(", ")}. ` +
+        `Set resource.postgres({ image }) to provide a custom Postgres image.`
+    );
+  }
+  return `pgvector/pgvector:pg${postgresMajorVersion(resource.version || "16")}-trixie`;
 }
 
 function normalizePostgresExtensions(extensions) {
-	if (extensions == null) return [];
-	if (!Array.isArray(extensions)) throw new Error("resource.postgres({ extensions }) must be an array");
-	return [...new Set(extensions.map((extension) => String(extension).trim().toLowerCase()).filter(Boolean))].sort();
+  if (extensions == null) return [];
+  if (!Array.isArray(extensions)) throw new Error("resource.postgres({ extensions }) must be an array");
+  return [...new Set(extensions.map((extension) => String(extension).trim().toLowerCase()).filter(Boolean))].sort();
 }
 
 function postgresMajorVersion(version) {
-	const match = String(version || "16").match(/^\d+/);
-	if (!match) throw new Error(`Invalid Postgres version for resource image selection: ${version}`);
-	return match[0];
+  const match = String(version || "16").match(/^\d+/);
+  if (!match) throw new Error(`Invalid Postgres version for resource image selection: ${version}`);
+  return match[0];
 }
 
-async function deleteManifestResources(manifest) {
+async function deleteManifestResources(manifest, options = {}) {
   const resources = manifest.resources || {};
-  if (Object.keys(resources).length === 0) return;
   const client = new KilnClient(manifest.kiln?.api || {});
   for (const resource of Object.values(resources)) {
     if (resource?.name) {
       await client.deleteAppliance(resource.name).catch(() => {});
     }
   }
+  if (options.includeEnvironmentVM && manifest.kiln?.vm?.name) {
+    await client.deleteVM(manifest.kiln.vm.name).catch(() => {});
+  }
+}
+
+async function cleanupKilnOrphans(manifest) {
+  const client = new KilnClient(manifest.kiln?.api || {});
+  await client.cleanup({ dry_run: false });
+}
+
+function removeKilnEnvironmentState(productDir, name) {
+  const environmentDir = getEnvironmentDir(productDir, name);
+  fs.rmSync(environmentDir, { recursive: true, force: true });
+  const parent = path.dirname(environmentDir);
+  try {
+    if (fs.existsSync(parent) && fs.readdirSync(parent).length === 0) {
+      fs.rmdirSync(parent);
+    }
+  } catch {
+    // Best-effort pruning only.
+  }
 }
 
 async function ensureVM(client, vmConfig, networkId) {

package/lib/ownership/docker.mjs

@@ -57,6 +57,23 @@ export async function listManagedDockerContainers() {
   ]);
 }
 
+export async function inspectDockerVolume(volumeRef) {
+  try {
+    const { stdout } = await execa("docker", ["volume", "inspect", volumeRef]);
+    const parsed = JSON.parse(stdout);
+    return parsed[0] || null;
+  } catch {
+    return null;
+  }
+}
+
+export async function listManagedDockerVolumes() {
+  return listDockerVolumes([
+    "--filter",
+    `label=${TESTKIT_MANAGED_LABEL}=true`,
+  ]);
+}
+
 export async function listLegacyTestkitPostgresContainers() {
   const containers = await listDockerContainers([]);
   return containers.filter((container) => {
@@ -67,7 +84,16 @@ export async function listLegacyTestkitPostgresContainers() {
 
 export async function removeDockerContainer(containerRef) {
   try {
-    await execa("docker", ["rm", "-f", containerRef]);
+    await execa("docker", ["rm", "-f", "-v", containerRef]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function removeDockerVolume(volumeRef) {
+  try {
+    await execa("docker", ["volume", "rm", "-f", volumeRef]);
     return true;
   } catch {
     return false;
@@ -88,6 +114,10 @@ export function dockerContainerSummary(container) {
   return `${container.name} (${status})`;
 }
 
+export function dockerVolumeSummary(volume) {
+  return `${volume.name}`;
+}
+
 async function listDockerContainers(filters) {
   let stdout = "";
   try {
@@ -114,6 +144,31 @@ async function listDockerContainers(filters) {
   return containers.map(normalizeInspectContainer).filter(Boolean);
 }
 
+async function listDockerVolumes(filters) {
+  let stdout = "";
+  try {
+    const result = await execa("docker", [
+      "volume",
+      "ls",
+      "-q",
+      ...filters,
+    ]);
+    stdout = result.stdout;
+  } catch {
+    return [];
+  }
+
+  const names = stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  if (names.length === 0) return [];
+
+  const volumes = [];
+  for (const name of names) {
+    const inspect = await inspectDockerVolume(name);
+    if (inspect) volumes.push(inspect);
+  }
+  return volumes.map(normalizeInspectVolume).filter(Boolean);
+}
+
 function normalizeInspectContainer(inspect) {
   if (!inspect?.Id) return null;
   const name = String(inspect.Name || "").replace(/^\//, "");
@@ -130,6 +185,17 @@ function normalizeInspectContainer(inspect) {
   };
 }
 
+function normalizeInspectVolume(inspect) {
+  if (!inspect?.Name) return null;
+  return {
+    name: inspect.Name,
+    driver: inspect.Driver || "",
+    mountpoint: inspect.Mountpoint || "",
+    labels: inspect.Labels || {},
+    createdAt: inspect.CreatedAt || null,
+  };
+}
+
 function canonicalizeProductDir(productDir) {
   const resolved = path.resolve(productDir || process.cwd());
   try {