@elench/testkit 0.1.149 → 0.1.151

package/lib/config-api/index.mjs

@@ -36,6 +36,9 @@ function postgresDatabase(options = {}) {
   }
   return {
     ...options,
+    ...(options.maxConnections ? { maxConnections: options.maxConnections } : {}),
+    ...(options.reservedConnections ? { reservedConnections: options.reservedConnections } : {}),
+    ...(options.runtimeConnections ? { runtimeConnections: options.runtimeConnections } : {}),
   };
 }
 
@@ -44,6 +47,9 @@ function postgresResource(options = {}) {
     kind: "postgres",
     version: options.version || "16",
     ...(options.image ? { image: options.image } : {}),
+    ...(options.maxConnections ? { maxConnections: options.maxConnections } : {}),
+    ...(options.reservedConnections ? { reservedConnections: options.reservedConnections } : {}),
+    ...(options.runtimeConnections ? { runtimeConnections: options.runtimeConnections } : {}),
     database: options.database || options.name || "app",
     user: options.user || "app",
     ...(options.password ? { password: options.password } : {}),

package/lib/database/cleanup.mjs

@@ -7,9 +7,12 @@ import {
   TESTKIT_SCOPE_LABEL,
   buildProductIdentity,
   dockerContainerSummary,
+  dockerVolumeSummary,
   listLegacyTestkitPostgresContainers,
   listManagedDockerContainers,
+  listManagedDockerVolumes,
   removeDockerContainer,
+  removeDockerVolume,
   stopDockerContainer,
 } from "../ownership/docker.mjs";
 import { buildContainerName } from "./naming.mjs";
@@ -22,6 +25,7 @@ import {
 export async function cleanupLocalPostgresDockerResources(options = {}) {
   const product = buildProductIdentity(options.productDir || process.cwd());
   const managed = await listManagedDockerContainers();
+  const managedVolumes = await listManagedDockerVolumes();
   const targets = [];
   const kept = [];
   const stopped = [];
@@ -38,6 +42,16 @@ export async function cleanupLocalPostgresDockerResources(options = {}) {
     }
   }
 
+  for (const volume of managedVolumes) {
+    if (!isManagedLocalPostgresVolume(volume)) continue;
+    const classification = classifyManagedLocalPostgresVolume(volume, product, options);
+    if (classification.action === "remove") {
+      targets.push({ ...volume, action: "remove", reason: classification.reason, legacy: false, resourceType: "volume" });
+    } else if (classification.reason) {
+      kept.push({ ...volume, reason: classification.reason, legacy: false, resourceType: "volume" });
+    }
+  }
+
   if (options.includeLegacy) {
     const currentLegacyName = buildContainerName(product.dir);
     for (const container of await listLegacyTestkitPostgresContainers()) {
@@ -51,6 +65,8 @@ export async function cleanupLocalPostgresDockerResources(options = {}) {
       if (container.action === "stop") {
         await stopDockerContainer(container.name || container.id);
         stopped.push(container);
+      } else if (container.resourceType === "volume") {
+        await removeDockerVolume(container.name);
       } else {
         await removeDockerContainer(container.name || container.id);
       }
@@ -71,7 +87,10 @@ export function formatDatabaseResourceCleanupLine(entry, dryRun = false) {
     ? isStop ? "Would stop" : "Would remove"
     : isStop ? "Stopped" : "Removed";
   const legacy = entry.legacy ? " legacy" : "";
-  return `${action}${legacy} database resource ${dockerContainerSummary(entry)} reason=${entry.reason}`;
+  const summary = entry.resourceType === "volume"
+    ? `volume ${dockerVolumeSummary(entry)}`
+    : dockerContainerSummary(entry);
+  return `${action}${legacy} database resource ${summary} reason=${entry.reason}`;
 }
 
 function classifyManagedLocalPostgresContainer(container, product, options) {
@@ -112,6 +131,41 @@ function classifyManagedLocalPostgresContainer(container, product, options) {
   return { action: "keep", reason: options.global ? "other-product-retained" : "different-product" };
 }
 
+function classifyManagedLocalPostgresVolume(volume, product, options) {
+  const labels = volume.labels || {};
+  const volumeProductId = labels[TESTKIT_PRODUCT_ID_LABEL] || "";
+  const volumeProductDir = labels[TESTKIT_PRODUCT_DIR_LABEL] || "";
+  const currentProduct = volumeProductId === product.id;
+
+  if (options.force && currentProduct) {
+    return { action: "remove", reason: "destroy-current-product" };
+  }
+
+  if (!options.global && !currentProduct) {
+    return { action: "keep", reason: "different-product" };
+  }
+
+  if (currentProduct) {
+    if (!hasRemainingLocalArtifacts(product.dir, readStateValue)) {
+      return { action: "remove", reason: "current-product-no-local-artifacts" };
+    }
+    if (!localArtifactsReferenceVolume(product.dir, volume.name)) {
+      return { action: "remove", reason: "current-product-unreferenced" };
+    }
+    return { action: "keep", reason: "current-product-referenced" };
+  }
+
+  if (options.global && volumeProductDir && !fs.existsSync(volumeProductDir)) {
+    return { action: "remove", reason: "product-dir-missing" };
+  }
+
+  if (options.global && volumeProductDir && !hasRemainingLocalArtifacts(volumeProductDir, readStateValue)) {
+    return { action: "remove", reason: "product-has-no-local-artifacts" };
+  }
+
+  return { action: "keep", reason: options.global ? "other-product-retained" : "different-product" };
+}
+
 function shouldStopIdleLocalPostgresContainer(container, productDir, options) {
   return Boolean(
     options.stopIdle &&
@@ -130,6 +184,14 @@ function isManagedLocalPostgresContainer(container) {
   );
 }
 
+function isManagedLocalPostgresVolume(volume) {
+  const labels = volume.labels || {};
+  return (
+    labels[TESTKIT_RESOURCE_KIND_LABEL] === "postgres-volume" &&
+    labels[TESTKIT_SCOPE_LABEL] === "local-postgres"
+  );
+}
+
 function localArtifactsReferenceContainer(productDir, containerName) {
   if (!containerName) return false;
   const root = path.join(productDir, ".testkit");
@@ -146,6 +208,19 @@ function localArtifactsReferenceContainer(productDir, containerName) {
   return referenced;
 }
 
+function localArtifactsReferenceVolume(productDir, volumeName) {
+  if (!volumeName) return false;
+  const root = path.join(productDir, ".testkit");
+  let referenced = false;
+  visitDirs(root, (dir) => {
+    if (referenced) return;
+    if (readStateValue(path.join(dir, "volume_name")) === volumeName) {
+      referenced = true;
+    }
+  });
+  return referenced;
+}
+
 function hasActiveProductRuntime(productDir) {
   return hasActiveRunManifest(productDir) || hasActiveLocalEnvironmentManifest(productDir);
 }

package/lib/database/constants.mjs

@@ -2,6 +2,9 @@ export const LOCAL_IMAGE = "pgvector/pgvector:pg16";
 export const LOCAL_USER = "testkit";
 export const LOCAL_PASSWORD = "testkit";
 export const LOCAL_ADMIN_DB = "postgres";
+export const LOCAL_MAX_CONNECTIONS = 200;
+export const LOCAL_RESERVED_CONNECTIONS = 20;
+export const LOCAL_RUNTIME_CONNECTIONS = 20;
 export const LOCAL_READY_TIMEOUT_MS = 60_000;
 export const LOCAL_POLL_INTERVAL_MS = 1_000;
 export const LOCAL_ADMIN_QUERY_RETRY_MS = 15_000;

package/lib/database/index.mjs

@@ -457,6 +457,12 @@ async function ensureRuntimeClone(config, infra, cacheDir, templateFingerprint,
   fs.writeFileSync(path.join(config.stateDir, `${backend}_template_database_name`), templateDbName);
   if (backend === "local") {
     fs.writeFileSync(path.join(config.stateDir, "local_container_name"), infra.containerName);
+    if (infra.volumeName) {
+      fs.writeFileSync(path.join(config.stateDir, "volume_name"), infra.volumeName);
+    }
+    if (infra.volumeMountPath) {
+      fs.writeFileSync(path.join(config.stateDir, "volume_mount_path"), infra.volumeMountPath);
+    }
   } else {
     fs.writeFileSync(path.join(config.stateDir, "resource_name"), infra.resourceName);
     writeResourceConnectionState(config.stateDir, infra);

package/lib/database/local-postgres.mjs

@@ -4,34 +4,61 @@ import { execa } from "execa";
 import {
   LOCAL_ADMIN_DB,
   LOCAL_IMAGE,
+  LOCAL_MAX_CONNECTIONS,
   LOCAL_PASSWORD,
   LOCAL_POLL_INTERVAL_MS,
   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;
+  const maxConnections = normalizeMaxConnections(
+    database.maxConnections || readStateValue(path.join(infraDir, "max_connections")) || LOCAL_MAX_CONNECTIONS
+  );
 
   let inspect = await inspectContainer(containerName);
-  if (inspect && inspect.Config?.Image !== image) {
+  if (
+    inspect &&
+    (
+      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",
@@ -39,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",
@@ -48,6 +77,9 @@ export async function ensureLocalContainer(productDir, database = {}) {
       "-p",
       "127.0.0.1::5432",
       image,
+      "postgres",
+      "-c",
+      `max_connections=${maxConnections}`,
     ]);
     inspect = await inspectContainer(containerName);
   } else if (!inspect.State?.Running) {
@@ -63,9 +95,12 @@ export async function ensureLocalContainer(productDir, database = {}) {
   const infra = {
     containerName,
     containerId: inspect.Id,
+    volumeName,
+    volumeMountPath,
     image,
     user,
     password,
+    maxConnections,
     host: "127.0.0.1",
     port: Number(hostPort),
   };
@@ -79,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;
@@ -94,9 +130,15 @@ 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,
+    maxConnections: normalizeMaxConnections(
+      readStateValue(path.join(infraDir, "max_connections")) || LOCAL_MAX_CONNECTIONS
+    ),
     host: "127.0.0.1",
     port: Number(hostPort),
   };
@@ -104,6 +146,29 @@ export async function loadExistingLocalContainer(productDir) {
   return infra;
 }
 
+function containerUsesMaxConnections(inspect, maxConnections) {
+  const cmd = inspect?.Config?.Cmd;
+  if (!Array.isArray(cmd)) return false;
+  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) {
+    throw new Error("database.maxConnections must be an integer greater than or equal to 10");
+  }
+  return number;
+}
+
 export async function inspectContainer(containerName) {
   try {
     const { stdout } = await execa("docker", ["inspect", containerName]);
@@ -116,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) {
@@ -153,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/resource-postgres.mjs

@@ -42,6 +42,9 @@ function normalizeResourcePostgresConnection(resourceName, connection) {
   const password = connection.password || fromUrl.password || "";
   const adminDatabase = connection.adminDatabase || connection.admin_database || fromUrl.database || LOCAL_ADMIN_DB;
   const sslMode = connection.sslMode || connection.sslmode || fromUrl.sslMode || "disable";
+  const maxConnections = normalizeOptionalMaxConnections(
+    connection.maxConnections || connection.max_connections
+  );
   if (!host) throw new Error(`Postgres resource "${resourceName}" connection is missing host`);
   if (!Number.isInteger(port) || port <= 0) {
     throw new Error(`Postgres resource "${resourceName}" connection has invalid port`);
@@ -54,11 +57,21 @@ function normalizeResourcePostgresConnection(resourceName, connection) {
     port,
     user,
     password,
+    ...(maxConnections ? { maxConnections } : {}),
     adminDatabase,
     sslMode,
   };
 }
 
+function normalizeOptionalMaxConnections(value) {
+  if (value == null || value === "") return undefined;
+  const number = Number(value);
+  if (!Number.isInteger(number) || number < 10) {
+    throw new Error("Postgres resource connection max_connections must be an integer greater than or equal to 10");
+  }
+  return number;
+}
+
 function parsePostgresConnectionUrl(rawUrl) {
   const parsed = new URL(rawUrl);
   return {

package/lib/database/state-files.mjs

@@ -8,10 +8,17 @@ 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);
   fs.writeFileSync(path.join(infraDir, "password"), infra.password);
+  fs.writeFileSync(path.join(infraDir, "max_connections"), String(infra.maxConnections));
   fs.writeFileSync(path.join(infraDir, "host"), infra.host);
   fs.writeFileSync(path.join(infraDir, "port"), String(infra.port));
 }
@@ -23,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);
@@ -34,6 +47,9 @@ export function writeResourceConnectionState(stateDir, infra) {
   fs.writeFileSync(path.join(stateDir, "resource_port"), String(infra.port));
   fs.writeFileSync(path.join(stateDir, "resource_user"), infra.user);
   fs.writeFileSync(path.join(stateDir, "resource_password"), infra.password);
+  if (infra.maxConnections) {
+    fs.writeFileSync(path.join(stateDir, "resource_max_connections"), String(infra.maxConnections));
+  }
   fs.writeFileSync(path.join(stateDir, "resource_admin_database"), infra.adminDatabase || LOCAL_ADMIN_DB);
   fs.writeFileSync(path.join(stateDir, "resource_sslmode"), infra.sslMode || "disable");
 }
@@ -47,6 +63,7 @@ export function readResourceConnectionState(stateDir, readStateValue) {
     port: Number(readStateValue(path.join(stateDir, "resource_port")) || 5432),
     user,
     password: readStateValue(path.join(stateDir, "resource_password")) || "",
+    maxConnections: Number(readStateValue(path.join(stateDir, "resource_max_connections")) || 0) || undefined,
     adminDatabase: readStateValue(path.join(stateDir, "resource_admin_database")) || LOCAL_ADMIN_DB,
     sslMode: readStateValue(path.join(stateDir, "resource_sslmode")) || "disable",
   };

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`);
   }