@rallycry/conveyor-k3 0.1.13 → 0.1.14

package/dist/index.js

@@ -4356,6 +4356,15 @@ var ALLOWED_FILE_ACCEPT = [
 var EMBED_THRESHOLD_IMAGES = 5 * 1024 * 1024;
 var EMBED_THRESHOLD_TEXT = 2 * 1024 * 1024;
 var IDLE_HEARTBEAT_MS = 90 * 1e3;
+var siteAssetExtension = external_exports.string().regex(/^[a-z0-9]{1,10}$/);
+var RequestSiteAssetUploadRequestSchema = external_exports.object({
+  projectId: external_exports.string(),
+  siteId: external_exports.string().min(1).max(100),
+  sha256: external_exports.string().regex(/^[a-f0-9]{64}$/),
+  ext: siteAssetExtension,
+  sizeBytes: external_exports.number().int().positive()
+});
+var ListSiteAssetTargetsRequestSchema = external_exports.object({ projectId: external_exports.string() });
 var TurnEndToolCallSchema = external_exports.object({
   tool: external_exports.string(),
   input: external_exports.string().optional(),
@@ -6266,6 +6275,8 @@ var ANTHROPIC_CATALOG = [
   anthropicEntry(DEFAULT_HAIKU_MODEL, "Haiku 4.5", 1, 5, { supportsEffort: false }),
   anthropicEntry(FABLE_MODEL, "Fable 5.1", 10, 50)
 ];
+var PROJECT_ARCHIVE_RETENTION_DAYS = 30;
+var RETENTION_MS = PROJECT_ARCHIVE_RETENTION_DAYS * 24 * 60 * 60 * 1e3;
 var CLAUDESPACE_WORKLOAD_LABEL = "rc-workload";
 var CLAUDESPACE_WORKLOAD_VALUE = "claudespace";
 var CONVEYOR_POD_SELECTOR = `${CLAUDESPACE_WORKLOAD_LABEL}=${CLAUDESPACE_WORKLOAD_VALUE}`;
@@ -6292,6 +6303,8 @@ var PERSONAL_LOCAL_REGISTRY_NAME = "conveyor-registry";
 var PERSONAL_LOCAL_REGISTRY_PORT = 5e3;
 var PERSONAL_LOCAL_REGISTRY_HOST = `${PERSONAL_LOCAL_REGISTRY_NAME}.${PERSONAL_LOCAL_REGISTRY_NAMESPACE}.svc.cluster.local:${PERSONAL_LOCAL_REGISTRY_PORT}`;
 var PERSONAL_LOCAL_REGISTRY_NODE_ENDPOINT = `http://127.0.0.1:${PERSONAL_LOCAL_REGISTRY_PORT}`;
+var PERSONAL_LOCAL_REGISTRY_PUSH_SECRET = "conveyor-registry-push";
+var PERSONAL_LOCAL_REGISTRY_PUSH_SECRET_KEY = "config.json";
 var BAKE_COMPONENT_LABEL = "claudespace.rallycry.com/component";
 var BAKE_COMPONENT_PREBAKE = "prebake";
 var BAKE_COMPONENT_STATE_BAKE = "state-bake";
@@ -6957,14 +6970,22 @@ async function readImageInventory(exec) {
   }
   return { images, referencedIds };
 }
+var CRICTL_RMI_TIMEOUT = "120s";
+var RMI_EXEC_TIMEOUT_MS = 15e4;
+var DEADLINE_EXCEEDED = "context deadline exceeded";
 async function pruneStrandedImages(exec, inventory, wantedImages) {
   const candidates = selectStrandedImages(inventory, wantedImages);
-  const result = { removed: 0, bytesReclaimed: 0, failures: [] };
+  const result = { removed: 0, bytesReclaimed: 0, failures: [], pending: [] };
   for (const candidate of candidates) {
-    const removal = await exec("crictl", ["rmi", candidate.id]);
+    const removal = await exec("crictl", ["--timeout", CRICTL_RMI_TIMEOUT, "rmi", candidate.id], {
+      timeoutMs: RMI_EXEC_TIMEOUT_MS
+    });
     if (removal.exitCode === 0) {
       result.removed += 1;
       result.bytesReclaimed += candidate.sizeBytes;
+    } else if (`${removal.stderr}
+${removal.stdout}`.includes(DEADLINE_EXCEEDED)) {
+      result.pending.push(candidate.id);
     } else {
       result.failures.push(`${candidate.id}: ${removal.stderr.trim().slice(0, 120)}`);
     }
@@ -7074,6 +7095,8 @@ var STATE_DIR = "/var/lib/conveyor-k3";
 var STATE_FILE = `${STATE_DIR}/state.json`;
 var LOCAL_REGISTRY_DATA_DIR = `${STATE_DIR}/registry`;
 var LOCAL_REGISTRY_MIRROR_RESTART_FILE = `${STATE_DIR}/registry-mirror-restart`;
+var LOCAL_REGISTRY_CREDENTIALS_FILE = `${STATE_DIR}/registry-credentials.json`;
+var LOCAL_REGISTRY_AUTH_STATE_FILE = `${STATE_DIR}/registry-auth.json`;
 var RANCHER_DIR = "/etc/rancher/k3s";
 var K3S_OWNER_CONFIG = `${RANCHER_DIR}/config.yaml`;
 var K3S_CONFIG_DROPIN_DIR = `${RANCHER_DIR}/config.yaml.d`;
@@ -7123,6 +7146,16 @@ function upsertRegistryAuth(file, host, auth) {
   next.configs = configs;
   return next;
 }
+function removeRegistryAuth(file, host) {
+  const existing = file.configs?.[host];
+  if (!existing?.auth) return file;
+  const { auth: _auth, ...rest } = existing;
+  const { [host]: _removed, ...others } = file.configs ?? {};
+  const configs = Object.keys(rest).length > 0 ? { ...others, [host]: rest } : others;
+  const next = { ...file, configs };
+  if (Object.keys(configs).length === 0) delete next.configs;
+  return next;
+}
 function mirrorEndpoints(file, host) {
   const entry = file.mirrors?.[host];
   if (!entry || typeof entry !== "object" || Array.isArray(entry)) return [];
@@ -7179,6 +7212,85 @@ function managesK3s(desired, state) {
   return desired.isolation === void 0 || state.k3sInstalledByConveyor === true;
 }
 
+// src/lib/manifest-guard.ts
+import { isAlias, isMap, isScalar, parseAllDocuments } from "yaml";
+var ALLOWED_MANIFEST_KINDS = [
+  "Namespace",
+  "Role",
+  "RoleBinding",
+  "ClusterRole",
+  "ClusterRoleBinding",
+  "PriorityClass"
+];
+var ALLOWED = new Set(ALLOWED_MANIFEST_KINDS);
+var MISSING_KIND = "(missing kind)";
+var UNPARSEABLE = "(unparseable)";
+var LIST_SHAPED = "(list-shaped document)";
+function isListShaped(map) {
+  return map.items.some(({ key }) => {
+    if (isAlias(key)) return true;
+    const name = isScalar(key) ? key.value : key;
+    return typeof name === "string" && (name === "<<" || name.toLowerCase() === "items");
+  });
+}
+function findDisallowedKinds(manifest) {
+  let documents;
+  try {
+    documents = parseAllDocuments(manifest);
+  } catch {
+    return [UNPARSEABLE];
+  }
+  const disallowed = [];
+  const record = (kind) => {
+    if (!disallowed.includes(kind)) disallowed.push(kind);
+  };
+  for (const doc of documents) {
+    if (doc.errors.length > 0) {
+      record(UNPARSEABLE);
+      continue;
+    }
+    if (doc.contents === null || doc.contents === void 0) continue;
+    if (isScalar(doc.contents) && doc.contents.value === null) continue;
+    if (!isMap(doc.contents)) {
+      record(MISSING_KIND);
+      continue;
+    }
+    if (isListShaped(doc.contents)) {
+      record(LIST_SHAPED);
+      continue;
+    }
+    const kind = doc.get("kind");
+    if (typeof kind !== "string" || kind.length === 0) {
+      record(MISSING_KIND);
+      continue;
+    }
+    if (!ALLOWED.has(kind)) record(kind);
+  }
+  return disallowed;
+}
+function withoutKind(manifest, kind) {
+  return parseAllDocuments(manifest).filter((doc) => !(isMap(doc.contents) && doc.get("kind") === kind)).map((doc) => doc.toString()).join("---\n");
+}
+function declaresPriorityClass(manifest, name, value) {
+  return parseAllDocuments(manifest).some(
+    (doc) => isMap(doc.contents) && doc.get("kind") === "PriorityClass" && doc.getIn(["metadata", "name"]) === name && doc.get("value") === value
+  );
+}
+
+// src/daemon/cluster-ops.ts
+async function kubectlApply(exec, manifest) {
+  await runOrThrow(exec, "k3s", ["kubectl", "apply", "-f", "-"], {
+    stdin: manifest,
+    timeoutMs: 6e4
+  });
+}
+function mayDisrupt(runningConveyorPods) {
+  return runningConveyorPods === 0;
+}
+function busyReason(runningConveyorPods) {
+  return runningConveyorPods === null ? "the number of running Conveyor pods could not be read" : `${runningConveyorPods} Conveyor pod(s) are running`;
+}
+
 // src/lib/k3s-config.ts
 var IMAGE_GC_HIGH = "image-gc-high-threshold";
 var IMAGE_GC_LOW = "image-gc-low-threshold";
@@ -7263,76 +7375,345 @@ function renderK3sDropIn(kubelet, ownerConfig, options = {}) {
   }
   return { content: [...lines2, ""].join("\n"), skipped };
 }
-var renderKubeletDropIn = renderK3sDropIn;
 
-// src/lib/manifest-guard.ts
-import { isMap, isScalar, parseAllDocuments } from "yaml";
-var ALLOWED_MANIFEST_KINDS = [
-  "Namespace",
-  "Role",
-  "RoleBinding",
-  "ClusterRole",
-  "ClusterRoleBinding",
-  "PriorityClass"
-];
-var ALLOWED = new Set(ALLOWED_MANIFEST_KINDS);
-var MISSING_KIND = "(missing kind)";
-var UNPARSEABLE = "(unparseable)";
-function findDisallowedKinds(manifest) {
-  let documents;
-  try {
-    documents = parseAllDocuments(manifest);
-  } catch {
-    return [UNPARSEABLE];
+// src/daemon/pod-cpu-quota.ts
+var POD_SLICE = "kubepods.slice";
+function cpuMillicores(quantity) {
+  const checked = assertQuantity(quantity, "reserveCpu");
+  const match = /^(\d+(?:\.\d+)?)(m?)$/.exec(checked);
+  if (!match?.[1])
+    throw new Error(`Invalid reserveCpu: ${JSON.stringify(checked)} is not a CPU amount`);
+  const amount = Number.parseFloat(match[1]);
+  return Math.round(match[2] === "m" ? amount : amount * 1e3);
+}
+function podCpuQuotaPercent(cores, reservedMillicores) {
+  const left = cores * 1e3 - reservedMillicores;
+  if (left < 10) return null;
+  return Math.floor(left / 10);
+}
+function setQuota(exec, value) {
+  return exec("systemctl", ["set-property", POD_SLICE, `CPUQuota=${value}`]);
+}
+async function liftPodCpuQuota(exec) {
+  const shown = await exec("systemctl", ["show", POD_SLICE, "-p", "CPUQuotaPerSecUSec", "--value"]);
+  if (shown.exitCode !== 0 || ["", "infinity"].includes(shown.stdout.trim())) return null;
+  const cleared = await setQuota(exec, "");
+  return cleared.exitCode === 0 ? null : cleared.stderr.trim().slice(0, 200);
+}
+async function reconcilePodCpuQuota(exec, desired, warnings) {
+  const reserve = desired.kubelet.systemReserved?.cpu;
+  if (!reserve) {
+    const failure = await liftPodCpuQuota(exec);
+    if (failure) warnings.push(`Could not lift the CPU cap on ${POD_SLICE}: ${failure}`);
+    return void 0;
   }
-  const disallowed = [];
-  const record = (kind) => {
-    if (!disallowed.includes(kind)) disallowed.push(kind);
+  const reserved = cpuMillicores(reserve);
+  const state = await exec("systemctl", ["show", POD_SLICE, "-p", "ActiveState", "--value"]);
+  if (state.exitCode !== 0 || state.stdout.trim() !== "active") {
+    warnings.push(
+      `Pods do not run under ${POD_SLICE} (k3s is not using the systemd cgroup driver), so the CPU you keep for this machine is weighted, not capped.`
+    );
+    return false;
+  }
+  const nproc = await exec("nproc", []);
+  const cores = Number.parseInt(nproc.stdout.trim(), 10);
+  if (nproc.exitCode !== 0 || !Number.isInteger(cores) || cores <= 0) {
+    warnings.push(
+      "Could not count this machine's CPUs, so the CPU you keep is weighted, not capped."
+    );
+    return false;
+  }
+  const percent = podCpuQuotaPercent(cores, reserved);
+  if (percent === null) {
+    warnings.push(
+      `The CPU you keep (${reserve}) leaves no CPU for builds on this ${cores}-CPU machine. Lower it in your Conveyor profile.`
+    );
+    return false;
+  }
+  const set = await setQuota(exec, `${percent}%`);
+  if (set.exitCode !== 0) {
+    warnings.push(
+      `Could not cap pod CPU at ${percent / 100} CPUs: ${set.stderr.trim().slice(0, 200)}`
+    );
+    return false;
+  }
+  return true;
+}
+
+// src/daemon/kubelet-upkeep.ts
+function ownerRestartWarning(change) {
+  return `${change} Conveyor did not install this server's k3s, so it never restarts it: run \`sudo systemctl restart k3s\` when no build runs.`;
+}
+async function reconcileKubelet(ctx, desired, result, managed) {
+  const ownerConfig = await ctx.fs.readFile(K3S_OWNER_CONFIG);
+  const rendered = renderK3sDropIn(desired.kubelet, ownerConfig, { disableComponents: managed });
+  result.skippedKubeletFlags = rendered.skipped;
+  result.effectiveImageGcHighThreshold = rendered.skipped.includes("image-gc-high-threshold") ? ownerImageGcHighThreshold(ownerConfig) : desired.kubelet.imageGcHighThreshold;
+  for (const flag of rendered.skipped) {
+    result.warnings.push(
+      `Left \`${flag}\` to your own /etc/rancher/k3s/config.yaml \u2014 Conveyor does not override a setting you chose.`
+    );
+  }
+  const current = await ctx.fs.readFile(K3S_CONFIG_DROPIN);
+  if (rendered.content === null) {
+    if (current !== null) await ctx.fs.removeFile(K3S_CONFIG_DROPIN);
+    return;
+  }
+  if (current === rendered.content) return;
+  await ctx.fs.ensureDir(K3S_CONFIG_DROPIN.slice(0, K3S_CONFIG_DROPIN.lastIndexOf("/")));
+  await ctx.fs.writeFile(K3S_CONFIG_DROPIN, rendered.content, 420);
+  if (!managed) {
+    result.warnings.push(ownerRestartWarning("Kubelet settings changed."));
+    return;
+  }
+  if (!mayDisrupt(ctx.runningConveyorPods)) {
+    result.warnings.push(
+      `Kubelet settings changed but ${busyReason(ctx.runningConveyorPods)} \u2014 the restart is deferred until the machine is idle.`
+    );
+    return;
+  }
+  const restart = await ctx.exec("systemctl", ["restart", "k3s"], { timeoutMs: 12e4 });
+  if (restart.exitCode === 0) {
+    result.restartedK3s = true;
+  } else {
+    result.warnings.push(
+      `Could not restart k3s to apply new kubelet settings: ${restart.stderr.trim().slice(0, 200)}`
+    );
+  }
+}
+
+// src/daemon/local-registry-upkeep.ts
+import { createHash as createHash3 } from "crypto";
+
+// src/lib/local-registry.ts
+import { createHash as createHash2 } from "crypto";
+
+// src/lib/registry-credentials.ts
+import { createHash, randomBytes as randomBytes2 } from "crypto";
+
+// src/lib/bcrypt.ts
+var P_WORDS = 18;
+var S_WORDS = 1024;
+var MAGIC = "OrpheanBeholderScryDoubt";
+var ALPHABET = "./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+var MAX_KEY_BYTES = 72;
+var BCRYPT_SALT_BYTES = 16;
+function scaledAtanInverse(x, one) {
+  const xSquared = x * x;
+  let power = one / x;
+  let sum = 0n;
+  for (let n = 0n; power !== 0n; n++) {
+    const term = power / (2n * n + 1n);
+    sum = n % 2n === 0n ? sum + term : sum - term;
+    power /= xSquared;
+  }
+  return sum;
+}
+function piFractionWords(count) {
+  const guard = 64n;
+  const bits = BigInt(count * 32) + guard;
+  const one = 1n << bits;
+  const pi = 16n * scaledAtanInverse(5n, one) - 4n * scaledAtanInverse(239n, one);
+  const fraction = pi - 3n * one >> guard;
+  const words = new Uint32Array(count);
+  for (let index = 0; index < count; index++) {
+    words[index] = Number(fraction >> BigInt(32 * (count - 1 - index)) & 0xffffffffn);
+  }
+  return words;
+}
+var initialState = null;
+function blowfishInitialState() {
+  if (!initialState) {
+    const words = piFractionWords(P_WORDS + S_WORDS);
+    initialState = { p: words.slice(0, P_WORDS), s: words.slice(P_WORDS) };
+  }
+  return initialState;
+}
+function word(array, index) {
+  return array[index] ?? 0;
+}
+function round(s, x) {
+  const mixed = word(s, x >>> 24) + word(s, 256 + (x >>> 16 & 255)) ^ word(s, 512 + (x >>> 8 & 255));
+  return mixed + word(s, 768 + (x & 255)) | 0;
+}
+function encipher(state, data, offset) {
+  const { p, s } = state;
+  let left = word(data, offset) ^ word(p, 0);
+  let right = word(data, offset + 1);
+  for (let index = 1; index <= 16; index += 2) {
+    right ^= round(s, left) ^ word(p, index);
+    left ^= round(s, right) ^ word(p, index + 1);
+  }
+  data[offset] = right ^ word(p, 17);
+  data[offset + 1] = left;
+}
+function wordStream(bytes) {
+  let position = 0;
+  return () => {
+    let value = 0;
+    for (let index = 0; index < 4; index++) {
+      value = value << 8 | (bytes[position] ?? 0);
+      position = (position + 1) % bytes.length;
+    }
+    return value >>> 0;
   };
-  for (const doc of documents) {
-    if (doc.errors.length > 0) {
-      record(UNPARSEABLE);
-      continue;
+}
+function expandKey(state, key, salt) {
+  const nextKeyWord = wordStream(key);
+  for (let index = 0; index < P_WORDS; index++) {
+    state.p[index] = word(state.p, index) ^ nextKeyWord();
+  }
+  const nextSaltWord = salt ? wordStream(salt) : () => 0;
+  const block = new Uint32Array(2);
+  const fill = (target, length) => {
+    for (let index = 0; index < length; index += 2) {
+      block[0] = word(block, 0) ^ nextSaltWord();
+      block[1] = word(block, 1) ^ nextSaltWord();
+      encipher(state, block, 0);
+      target[index] = word(block, 0);
+      target[index + 1] = word(block, 1);
     }
-    if (doc.contents === null || doc.contents === void 0) continue;
-    if (isScalar(doc.contents) && doc.contents.value === null) continue;
-    if (!isMap(doc.contents)) {
-      record(MISSING_KIND);
-      continue;
+  };
+  fill(state.p, P_WORDS);
+  fill(state.s, S_WORDS);
+}
+function encodeBase64(bytes, length) {
+  let out = "";
+  let offset = 0;
+  while (offset < length) {
+    let first = bytes[offset++] ?? 0;
+    out += ALPHABET[first >> 2];
+    first = (first & 3) << 4;
+    if (offset >= length) {
+      out += ALPHABET[first];
+      break;
     }
-    const kind = doc.get("kind");
-    if (typeof kind !== "string" || kind.length === 0) {
-      record(MISSING_KIND);
-      continue;
+    let second = bytes[offset++] ?? 0;
+    out += ALPHABET[first | second >> 4];
+    first = (second & 15) << 2;
+    if (offset >= length) {
+      out += ALPHABET[first];
+      break;
     }
-    if (!ALLOWED.has(kind)) record(kind);
-  }
-  return disallowed;
+    second = bytes[offset++] ?? 0;
+    out += ALPHABET[first | second >> 6];
+    out += ALPHABET[second & 63];
+  }
+  return out;
+}
+function bcryptHash(password, cost, salt) {
+  if (!Number.isInteger(cost) || cost < 4 || cost > 31) {
+    throw new Error(`bcrypt cost must be an integer from 4 to 31, not ${cost}`);
+  }
+  if (salt.length !== BCRYPT_SALT_BYTES) {
+    throw new Error(`bcrypt needs a ${BCRYPT_SALT_BYTES}-byte salt`);
+  }
+  const passwordBytes = new TextEncoder().encode(password).slice(0, MAX_KEY_BYTES);
+  const key = new Uint8Array(passwordBytes.length + 1);
+  key.set(passwordBytes);
+  const base = blowfishInitialState();
+  const state = { p: base.p.slice(), s: base.s.slice() };
+  expandKey(state, key, salt);
+  for (let rounds = 2 ** cost; rounds > 0; rounds--) {
+    expandKey(state, key, null);
+    expandKey(state, salt, null);
+  }
+  const magic = new TextEncoder().encode(MAGIC);
+  const nextMagicWord = wordStream(magic);
+  const block = Uint32Array.from({ length: 6 }, () => nextMagicWord());
+  for (let pass = 0; pass < 64; pass++) {
+    for (let offset = 0; offset < 6; offset += 2) encipher(state, block, offset);
+  }
+  const digest = new Uint8Array(24);
+  block.forEach((value, index) => {
+    digest[index * 4] = value >>> 24;
+    digest[index * 4 + 1] = value >>> 16 & 255;
+    digest[index * 4 + 2] = value >>> 8 & 255;
+    digest[index * 4 + 3] = value & 255;
+  });
+  const costText = String(cost).padStart(2, "0");
+  return `$2y$${costText}$${encodeBase64(salt, BCRYPT_SALT_BYTES)}${encodeBase64(digest, 23)}`;
 }
 
-// src/daemon/cluster-ops.ts
-async function kubectlApply(exec, manifest) {
-  await runOrThrow(exec, "k3s", ["kubectl", "apply", "-f", "-"], {
-    stdin: manifest,
-    timeoutMs: 6e4
-  });
+// src/lib/registry-credentials.ts
+var LOCAL_REGISTRY_USERNAME = "conveyor";
+var BCRYPT_COST = 5;
+var USERNAME = /^[a-z][a-z0-9-]{0,31}$/;
+var PASSWORD = /^[A-Za-z0-9_-]{32,128}$/;
+function generateRegistryCredentials(random = randomBytes2) {
+  const username = LOCAL_REGISTRY_USERNAME;
+  const password = Buffer.from(random(32)).toString("base64url");
+  const hash = bcryptHash(password, BCRYPT_COST, random(BCRYPT_SALT_BYTES));
+  return { username, password, htpasswd: `${username}:${hash}` };
+}
+function parseRegistryCredentials(raw) {
+  if (!raw) return null;
+  try {
+    const value = JSON.parse(raw);
+    const { username, password, htpasswd } = value ?? {};
+    if (typeof username !== "string" || !USERNAME.test(username)) return null;
+    if (typeof password !== "string" || !PASSWORD.test(password)) return null;
+    if (typeof htpasswd !== "string" || !htpasswd.startsWith(`${username}:$2`)) return null;
+    if (htpasswd.includes("\n")) return null;
+    return { username, password, htpasswd };
+  } catch {
+    return null;
+  }
 }
-function mayDisrupt(runningConveyorPods) {
-  return runningConveyorPods === 0;
+async function loadOrCreateRegistryCredentials(fs, random) {
+  const stored = parseRegistryCredentials(await fs.readFile(LOCAL_REGISTRY_CREDENTIALS_FILE));
+  if (stored) return stored;
+  const created = generateRegistryCredentials(random);
+  await fs.writeFile(LOCAL_REGISTRY_CREDENTIALS_FILE, `${JSON.stringify(created)}
+`, 384);
+  return created;
 }
-function busyReason(runningConveyorPods) {
-  return runningConveyorPods === null ? "the number of running Conveyor pods could not be read" : `${runningConveyorPods} Conveyor pod(s) are running`;
+function credentialFingerprint(credentials) {
+  return createHash("sha256").update(`${credentials.username}:${credentials.password}`).digest("hex").slice(0, 16);
+}
+function basicAuthorization(credentials) {
+  return `Basic ${Buffer.from(`${credentials.username}:${credentials.password}`).toString("base64")}`;
+}
+function registryDockerConfig(credentials, host) {
+  const auth = Buffer.from(`${credentials.username}:${credentials.password}`).toString("base64");
+  return JSON.stringify({ auths: { [host]: { auth } } });
+}
+function parseRegistryAuthState(raw) {
+  if (!raw) return null;
+  try {
+    const value = JSON.parse(raw);
+    if (typeof value?.credential !== "string") return null;
+    const writtenAt = typeof value.writtenAt === "string" && !Number.isNaN(Date.parse(value.writtenAt)) ? value.writtenAt : null;
+    return { credential: value.credential, writtenAt, enforced: value.enforced === true };
+  } catch {
+    return null;
+  }
+}
+async function registryAuthEnforced(readFile3) {
+  return parseRegistryAuthState(await readFile3(LOCAL_REGISTRY_AUTH_STATE_FILE))?.enforced === true;
+}
+function withRegistryCredentials(fetchImpl, readFile3) {
+  let credentials = null;
+  return async (url, init) => {
+    credentials ??= readFile3(LOCAL_REGISTRY_CREDENTIALS_FILE).then(parseRegistryCredentials);
+    const stored = await credentials;
+    if (!stored) return fetchImpl(url, init);
+    const headers = new Headers(init?.headers);
+    headers.set("Authorization", basicAuthorization(stored));
+    return fetchImpl(url, { ...init, headers });
+  };
 }
-
-// src/daemon/local-registry-upkeep.ts
-import { createHash } from "crypto";
 
 // src/lib/local-registry.ts
 var LOCAL_REGISTRY_IMAGE = "docker.io/library/registry:3.1.2@sha256:c87f33837722a100572e95d7dc4bf539fc42cf68202b13c3bc03c0ff54c3a649";
 var LOCAL_REGISTRY_CONFIG = "/etc/distribution/config.yml";
 var LOCAL_REGISTRY_GC_JOB = "conveyor-registry-gc";
+var LOCAL_REGISTRY_HTPASSWD_SECRET = "conveyor-registry-htpasswd";
+var HTPASSWD_KEY = "htpasswd";
+var AUTH_MOUNT = "/etc/distribution/auth";
 var LOCAL_REGISTRY_SELECTOR = { "app.kubernetes.io/name": PERSONAL_LOCAL_REGISTRY_NAME };
 var MANAGED_BY = { "app.kubernetes.io/managed-by": "conveyor-k3" };
+var AUTH_CHECKSUM_ANNOTATION = "conveyor.rallycry.com/registry-auth";
 var DATA_MOUNT = "/var/lib/registry";
 var REGISTRY_ENV = [
   { name: "REGISTRY_STORAGE_DELETE_ENABLED", value: "true" },
@@ -7347,6 +7728,23 @@ var VOLUME_MOUNTS = [
   { name: "data", mountPath: DATA_MOUNT },
   { name: "tmp", mountPath: "/tmp" }
 ];
+var AUTH_ENV = [
+  { name: "REGISTRY_AUTH", value: "htpasswd" },
+  { name: "REGISTRY_AUTH_HTPASSWD_REALM", value: "conveyor" },
+  { name: "REGISTRY_AUTH_HTPASSWD_PATH", value: `${AUTH_MOUNT}/${HTPASSWD_KEY}` }
+];
+var AUTH_VOLUME = {
+  name: "auth",
+  secret: {
+    secretName: LOCAL_REGISTRY_HTPASSWD_SECRET,
+    items: [{ key: HTPASSWD_KEY, path: HTPASSWD_KEY }],
+    defaultMode: 256
+  }
+};
+var AUTH_VOLUME_MOUNT = { name: "auth", mountPath: AUTH_MOUNT, readOnly: true };
+function htpasswdChecksum(htpasswd) {
+  return createHash2("sha256").update(htpasswd).digest("hex").slice(0, 16);
+}
 var VOLUMES = [
   { name: "data", hostPath: { path: LOCAL_REGISTRY_DATA_DIR, type: "Directory" } },
   { name: "tmp", emptyDir: { sizeLimit: "64Mi" } }
@@ -7383,7 +7781,34 @@ function registryNetworkPolicy(metadata) {
     }
   };
 }
-function renderLocalRegistryManifests() {
+function renderLocalRegistrySecrets(credentials) {
+  const encode = (value) => Buffer.from(value).toString("base64");
+  const secret = (namespace, name, key, value) => ({
+    apiVersion: "v1",
+    kind: "Secret",
+    metadata: { name, namespace, labels: { ...MANAGED_BY } },
+    type: "Opaque",
+    data: { [key]: encode(value) }
+  });
+  const items = [
+    secret(
+      PERSONAL_LOCAL_REGISTRY_NAMESPACE,
+      LOCAL_REGISTRY_HTPASSWD_SECRET,
+      HTPASSWD_KEY,
+      `${credentials.htpasswd}
+`
+    ),
+    secret(
+      PERSONAL_BAKE_NAMESPACE,
+      PERSONAL_LOCAL_REGISTRY_PUSH_SECRET,
+      PERSONAL_LOCAL_REGISTRY_PUSH_SECRET_KEY,
+      registryDockerConfig(credentials, PERSONAL_LOCAL_REGISTRY_HOST)
+    )
+  ];
+  return `${JSON.stringify({ apiVersion: "v1", kind: "List", items }, null, 2)}
+`;
+}
+function renderLocalRegistryManifests(auth = null) {
   const metadata = {
     name: PERSONAL_LOCAL_REGISTRY_NAME,
     namespace: PERSONAL_LOCAL_REGISTRY_NAMESPACE,
@@ -7399,15 +7824,19 @@ function renderLocalRegistryManifests() {
       strategy: { type: "Recreate" },
       selector: { matchLabels: LOCAL_REGISTRY_SELECTOR },
       template: {
-        metadata: { labels: metadata.labels },
+        metadata: {
+          labels: metadata.labels,
+          ...auth ? { annotations: { [AUTH_CHECKSUM_ANNOTATION]: htpasswdChecksum(auth.htpasswd) } } : {}
+        },
         spec: {
           ...POD_BASE,
+          ...auth ? { volumes: [...VOLUMES, AUTH_VOLUME] } : {},
           containers: [
             {
               name: "registry",
               image: LOCAL_REGISTRY_IMAGE,
               imagePullPolicy: "IfNotPresent",
-              env: REGISTRY_ENV,
+              env: auth ? [...REGISTRY_ENV, ...AUTH_ENV] : REGISTRY_ENV,
               ports: [
                 {
                   name: "registry",
@@ -7419,8 +7848,10 @@ function renderLocalRegistryManifests() {
                   protocol: "TCP"
                 }
               ],
+              // A TCP check: once the credential is enforced, `/v2/` answers
+              // 401 to a probe that does not carry it.
               readinessProbe: {
-                httpGet: { path: "/v2/", port: PERSONAL_LOCAL_REGISTRY_PORT },
+                tcpSocket: { port: PERSONAL_LOCAL_REGISTRY_PORT },
                 periodSeconds: 10
               },
               resources: {
@@ -7428,7 +7859,7 @@ function renderLocalRegistryManifests() {
                 limits: { memory: "512Mi" }
               },
               securityContext: CONTAINER_SECURITY,
-              volumeMounts: VOLUME_MOUNTS
+              volumeMounts: auth ? [...VOLUME_MOUNTS, AUTH_VOLUME_MOUNT] : VOLUME_MOUNTS
             }
           ]
         }
@@ -7519,11 +7950,18 @@ async function registryAnswers(fetchImpl = fetch) {
 }
 async function localRegistryReady(ports) {
   const [answers, mirrored] = await Promise.all([
-    registryAnswers(ports.fetch),
+    registryAnswers(withRegistryCredentials(ports.fetch ?? fetch, ports.readFile)),
     mirrorLoaded(ports.readFile)
   ]);
   return answers && mirrored;
 }
+async function localRegistryStatus(ports) {
+  const [ready, authEnforced] = await Promise.all([
+    localRegistryReady(ports),
+    registryAuthEnforced(ports.readFile)
+  ]);
+  return { ready, authEnforced };
+}
 
 // src/daemon/registry-gc-lock.ts
 var REGISTRY_GC_MARK = "conveyor.rallycry.com/registry-gc";
@@ -7614,6 +8052,59 @@ async function deleteSweepJob(exec) {
   return result.exitCode === 0;
 }
 
+// src/daemon/registry-auth.ts
+var LOCAL_REGISTRY_AUTH_HOSTS = [
+  PERSONAL_LOCAL_REGISTRY_HOST,
+  new URL(PERSONAL_LOCAL_REGISTRY_NODE_ENDPOINT).host
+];
+function registryAuthConfigured(file, credentials) {
+  return LOCAL_REGISTRY_AUTH_HOSTS.every((host) => {
+    const auth = file.configs?.[host]?.auth;
+    return auth?.username === credentials.username && auth.password === credentials.password && auth.auth === void 0 && auth.identitytoken === void 0;
+  });
+}
+function withLocalRegistryAuth(file, credentials) {
+  return LOCAL_REGISTRY_AUTH_HOSTS.reduce(
+    (next, host) => upsertRegistryAuth(next, host, {
+      username: credentials.username,
+      password: credentials.password
+    }),
+    file
+  );
+}
+function monotonicNowUs() {
+  return Number(process.hrtime.bigint() / 1000n);
+}
+async function k3sStartedAtMs(exec, nowMs, monotonicNow = monotonicNowUs) {
+  const result = await exec(
+    "systemctl",
+    ["show", "k3s", "--property=ActiveEnterTimestampMonotonic", "--value"],
+    { timeoutMs: 1e4 }
+  ).catch(() => null);
+  if (!result || result.exitCode !== 0) return null;
+  const startedUs = Number.parseInt(result.stdout.trim(), 10);
+  if (!Number.isFinite(startedUs) || startedUs <= 0) return null;
+  return nowMs - (monotonicNow() - startedUs) / 1e3;
+}
+async function settleRegistryAuth(ctx, credentials, written) {
+  const now = (ctx.now ?? (() => /* @__PURE__ */ new Date()))();
+  const raw = await ctx.fs.readFile(LOCAL_REGISTRY_AUTH_STATE_FILE);
+  const credential = credentialFingerprint(credentials);
+  const stored = parseRegistryAuthState(raw);
+  const state = stored?.credential === credential ? stored : { credential, writtenAt: null, enforced: false };
+  if (!state.enforced && (written || state.writtenAt === null)) {
+    state.writtenAt = now.toISOString();
+  }
+  if (!state.enforced && state.writtenAt !== null) {
+    const startedAt = await k3sStartedAtMs(ctx.exec, now.getTime(), ctx.monotonicNowUs);
+    if (startedAt !== null && startedAt > Date.parse(state.writtenAt)) state.enforced = true;
+  }
+  const next = `${JSON.stringify(state)}
+`;
+  if (next !== raw) await ctx.fs.writeFile(LOCAL_REGISTRY_AUTH_STATE_FILE, next, 384);
+  return state.enforced;
+}
+
 // src/daemon/local-registry-upkeep.ts
 function nowDate() {
   return /* @__PURE__ */ new Date();
@@ -7622,33 +8113,47 @@ function mirrorConfigured(raw) {
   const endpoints = mirrorEndpoints(parseRegistries(raw), PERSONAL_LOCAL_REGISTRY_HOST);
   return endpoints.length === 1 && endpoints[0] === PERSONAL_LOCAL_REGISTRY_NODE_ENDPOINT;
 }
-async function applyUnlessCollecting(ctx) {
+async function applyUnlessCollecting(ctx, auth) {
   const deployment = await readRegistryDeployment(ctx.exec);
   if (!deployment) throw new Error("the registry's Deployment could not be read");
   if (gcMarkIsLive(deployment.mark, (ctx.now ?? nowDate)().getTime(), ctx.isAlive)) return false;
   if (deployment.mark !== null && !await deleteSweepJob(ctx.exec)) {
     throw new Error("a stopped cleanup's Job could not be deleted, so the registry stays stopped");
   }
-  await kubectlApply(ctx.exec, renderLocalRegistryManifests());
+  await kubectlApply(ctx.exec, renderLocalRegistryManifests(auth));
   if (deployment.mark !== null) await clearGcMark(ctx.exec);
   return true;
 }
 async function deployLocalRegistry(ctx) {
   await ctx.fs.ensureDir(LOCAL_REGISTRY_DATA_DIR, 448);
-  const applied = await applyUnlessCollecting(ctx);
+  const credentials = await loadOrCreateRegistryCredentials(ctx.fs, ctx.random);
   const raw = await ctx.fs.readFile(REGISTRIES_FILE);
-  if (mirrorConfigured(raw)) return { applied, mirrorWritten: false, backupPath: null };
-  const next = upsertRegistryMirror(parseRegistries(raw), PERSONAL_LOCAL_REGISTRY_HOST, [
-    PERSONAL_LOCAL_REGISTRY_NODE_ENDPOINT
-  ]);
-  const backupPath = await writeRegistriesWithBackup(ctx.fs, raw, next, (ctx.now ?? nowDate)());
-  return { applied, mirrorWritten: true, backupPath };
+  let file = parseRegistries(raw);
+  const mirrorWritten = !mirrorConfigured(raw);
+  const authWritten = !registryAuthConfigured(file, credentials);
+  let backupPath = null;
+  if (mirrorWritten) {
+    file = upsertRegistryMirror(file, PERSONAL_LOCAL_REGISTRY_HOST, [
+      PERSONAL_LOCAL_REGISTRY_NODE_ENDPOINT
+    ]);
+  }
+  if (authWritten) file = withLocalRegistryAuth(file, credentials);
+  if (mirrorWritten || authWritten) {
+    backupPath = await writeRegistriesWithBackup(ctx.fs, raw, file, (ctx.now ?? nowDate)());
+  }
+  const authEnforced = await settleRegistryAuth(ctx, credentials, authWritten);
+  await kubectlApply(ctx.exec, renderLocalRegistrySecrets(credentials));
+  const applied = await applyUnlessCollecting(ctx, authEnforced ? credentials : null);
+  return { applied, mirrorWritten, authWritten, backupPath, authEnforced };
 }
 async function readMirrorState(fs) {
   const raw = await fs.readFile(REGISTRIES_FILE);
-  const fingerprint = createHash("sha256").update(raw ?? "").digest("hex");
+  const authPending = !await registryAuthEnforced((path) => fs.readFile(path));
+  const fingerprint = createHash3("sha256").update(raw ?? "").digest("hex");
   if (!mirrorConfigured(raw)) return { state: "absent", fingerprint };
-  if (await mirrorLoaded((path) => fs.readFile(path))) return { state: "loaded", fingerprint };
+  if (!authPending && await mirrorLoaded((path) => fs.readFile(path))) {
+    return { state: "loaded", fingerprint };
+  }
   const tried = (await fs.readFile(LOCAL_REGISTRY_MIRROR_RESTART_FILE))?.trim() === fingerprint;
   return { state: tried ? "tried" : "owed", fingerprint };
 }
@@ -7660,14 +8165,14 @@ async function loadRegistryMirror(ctx) {
   if (state === "tried") {
     return {
       restarted: false,
-      warning: `k3s restarted but did not load the local image registry's mirror, so pods cannot pull from that registry. Conveyor restarts k3s for it again only after /etc/rancher/k3s/registries.yaml changes. Check that k3s reads that file and keeps its data in the default directory: the mirror should appear under ${K3S_CERTS_D}.`
+      warning: `k3s restarted but did not load the local image registry's mirror or credential, so pods cannot pull from that registry or the registry stays open to every account on this machine. Conveyor restarts k3s for it again only after /etc/rancher/k3s/registries.yaml changes. Check that k3s reads that file and keeps its data in the default directory: the mirror should appear under ${K3S_CERTS_D}.`
     };
   }
   if (state !== "owed") return { restarted: false, warning: null };
   if (!mayDisrupt(ctx.runningConveyorPods)) {
     return {
       restarted: false,
-      warning: `The local image registry needs a k3s restart to load its mirror, but ${busyReason(ctx.runningConveyorPods)} \u2014 the restart is deferred until the machine is idle.`
+      warning: `The local image registry needs a k3s restart to load its mirror or credential, but ${busyReason(ctx.runningConveyorPods)} \u2014 the restart is deferred until the machine is idle.`
     };
   }
   const restart = await ctx.exec("systemctl", ["restart", "k3s"], { timeoutMs: 12e4 });
@@ -7849,7 +8354,18 @@ async function stdoutOf(exec, bin, args) {
   const run = await exec(bin, args, { timeoutMs: 1e4 }).catch(() => null);
   return run && run.exitCode === 0 ? run.stdout : null;
 }
+async function dropInDirExists(exec) {
+  const run = await exec("test", ["-d", K3S_CONFIG_DROPIN_DIR], { timeoutMs: 1e4 }).catch(
+    () => null
+  );
+  if (run === null) return null;
+  if (run.exitCode === 0) return true;
+  return run.exitCode === 1 && run.stderr.trim() === "" ? false : null;
+}
 async function readK3sConfigs(ctx) {
+  const dirExists = await dropInDirExists(ctx.exec);
+  if (dirExists === null) return null;
+  if (!dirExists) return [await ctx.fs.readFile(K3S_OWNER_CONFIG)];
   const listed = await stdoutOf(ctx.exec, "find", [
     "-L",
     K3S_CONFIG_DROPIN_DIR,
@@ -8106,6 +8622,55 @@ async function reconcileIsolation(ctx, desired, result) {
   result.isolation = { applied };
 }
 
+// src/lib/fs-port.ts
+import { chmod, mkdir, readFile, rm, writeFile } from "fs/promises";
+var nodeFileSystem = {
+  async readFile(path) {
+    try {
+      return await readFile(path, "utf8");
+    } catch {
+      return null;
+    }
+  },
+  async writeFile(path, content, mode) {
+    await mkdir(path.slice(0, path.lastIndexOf("/")), { recursive: true });
+    await writeFile(path, content, { encoding: "utf8", ...mode === void 0 ? {} : { mode } });
+    if (mode !== void 0) await chmod(path, mode);
+  },
+  async removeFile(path) {
+    await rm(path, { force: true });
+  },
+  async ensureDir(path, mode) {
+    await mkdir(path, { recursive: true });
+    if (mode !== void 0) await chmod(path, mode);
+  }
+};
+function createMemoryFileSystem(seed = {}) {
+  const files = new Map(Object.entries(seed));
+  const modes = /* @__PURE__ */ new Map();
+  const removed = [];
+  return {
+    files,
+    modes,
+    removed,
+    readFile: (path) => Promise.resolve(files.get(path) ?? null),
+    writeFile: (path, content, mode) => {
+      files.set(path, content);
+      if (mode !== void 0) modes.set(path, mode);
+      return Promise.resolve();
+    },
+    removeFile: (path) => {
+      files.delete(path);
+      removed.push(path);
+      return Promise.resolve();
+    },
+    ensureDir: (path, mode) => {
+      if (mode !== void 0) modes.set(path, mode);
+      return Promise.resolve();
+    }
+  };
+}
+
 // src/daemon/registry-tags.ts
 var REPO_NAME = /^[a-z0-9]+(?:[._-][a-z0-9]+)*(?:\/[a-z0-9]+(?:[._-][a-z0-9]+)*)*$/;
 var TAG_NAME = /^[A-Za-z0-9_][A-Za-z0-9._-]{0,127}$/;
@@ -8391,7 +8956,10 @@ async function collectRegistryGarbage(ports, options) {
     blobsCollected: false
   });
   const now = ports.now ?? Date.now;
-  const fetchImpl = ports.fetch ?? fetch;
+  const fetchImpl = withRegistryCredentials(
+    ports.fetch ?? fetch,
+    ports.readFile ?? ((path) => nodeFileSystem.readFile(path))
+  );
   const retain = await readRetainList(ports);
   if (typeof retain === "string") return skip(retain);
   const blocked = await registryBlocker(ports, now());
@@ -8557,17 +9125,26 @@ var GRANTED_COMMAND_NAMES = LOCAL_BAKE_ROOT_COMMANDS.map((command) => command.na
 
 // src/daemon/telemetry.ts
 var LOCAL_REGISTRY_WARN_AFTER_MS = 10 * 6e4;
+var LOCAL_REGISTRY_OPEN_WARNING = "The local image registry is open to every account on this machine: any of them can read and replace the images your workspaces start from. It requires its credential once k3s restarts and loads it.";
 async function reportLocalRegistry(ports, watch, now = Date.now()) {
   if (!watch) return { fields: {}, warnings: [] };
-  const ready = await localRegistryReady({ readFile: ports.readFile, fetch: ports.fetch });
+  const { ready, authEnforced } = await localRegistryStatus({
+    readFile: ports.readFile,
+    fetch: ports.fetch
+  });
   const paused = (watch.pausedUntil ?? 0) > now;
   watch.notReadySince = ready || paused ? null : watch.notReadySince ?? now;
   const stuckMs = watch.notReadySince === null ? 0 : now - watch.notReadySince;
-  return {
-    fields: { localRegistry: { host: PERSONAL_LOCAL_REGISTRY_HOST, ready } },
-    warnings: stuckMs >= LOCAL_REGISTRY_WARN_AFTER_MS ? [
+  const warnings = [];
+  if (stuckMs >= LOCAL_REGISTRY_WARN_AFTER_MS) {
+    warnings.push(
       `The local image registry has not been ready for ${Math.floor(stuckMs / 6e4)} minutes, so shadow bakes cannot use it yet. Check its pod with \`k3s kubectl -n conveyor-system get pods -l app.kubernetes.io/name=conveyor-registry\`. If the pod is running, k3s has not loaded the registry's mirror yet: it restarts k3s for that only while no Conveyor pod runs.`
-    ] : []
+    );
+  }
+  if (!authEnforced) warnings.push(LOCAL_REGISTRY_OPEN_WARNING);
+  return {
+    fields: { localRegistry: { host: PERSONAL_LOCAL_REGISTRY_HOST, ready, authEnforced } },
+    warnings
   };
 }
 var VM_CAPACITY_FILE = "/etc/conveyor-vm/capacity.json";
@@ -8690,6 +9267,7 @@ async function collectHeartbeat(ports, state, inventory) {
     ...localImages ? { localImages } : {},
     ...registry.fields,
     ...state.isolation ? { isolation: state.isolation } : {},
+    ...state.cpuQuotaApplied === void 0 ? {} : { cpuQuotaApplied: state.cpuQuotaApplied },
     localWarnings: withinHeartbeatBounds([
       ...state.localWarnings,
       ...gcWarning ? [gcWarning] : [],
@@ -8740,7 +9318,15 @@ async function collect(ports, now) {
   if (watch) watch.pausedUntil = now.getTime() + REGISTRY_GC_MARK_TTL_MS;
   try {
     const outcome = await collectRegistryGarbage(
-      { exec, log, requestDesiredState, fetch: fetch2, sleep: sleep2, isAlive },
+      {
+        exec,
+        log,
+        requestDesiredState,
+        fetch: fetch2,
+        readFile: (path) => ports.fs.readFile(path),
+        sleep: sleep2,
+        isAlive
+      },
       { dryRun: false }
     );
     if (outcome.skipped) return outcome.skipped;
@@ -8786,48 +9372,7 @@ async function runRegistryUpkeep(ports, lastGcAt, maintenanceHour) {
 }
 
 // src/daemon/reconcile.ts
-function ownerRestartWarning(change) {
-  return `${change} Conveyor did not install this server's k3s, so it never restarts it: run \`sudo systemctl restart k3s\` when no build runs.`;
-}
-async function reconcileKubelet(ctx, desired, result, managed) {
-  const ownerConfig = await ctx.fs.readFile(K3S_OWNER_CONFIG);
-  const rendered = renderK3sDropIn(desired.kubelet, ownerConfig, { disableComponents: managed });
-  result.skippedKubeletFlags = rendered.skipped;
-  result.effectiveImageGcHighThreshold = rendered.skipped.includes("image-gc-high-threshold") ? ownerImageGcHighThreshold(ownerConfig) : desired.kubelet.imageGcHighThreshold;
-  for (const flag of rendered.skipped) {
-    result.warnings.push(
-      `Left \`${flag}\` to your own /etc/rancher/k3s/config.yaml \u2014 Conveyor does not override a setting you chose.`
-    );
-  }
-  const current = await ctx.fs.readFile(K3S_CONFIG_DROPIN);
-  if (rendered.content === null) {
-    if (current !== null) await ctx.fs.removeFile(K3S_CONFIG_DROPIN);
-    return;
-  }
-  if (current === rendered.content) return;
-  await ctx.fs.ensureDir(K3S_CONFIG_DROPIN.slice(0, K3S_CONFIG_DROPIN.lastIndexOf("/")));
-  await ctx.fs.writeFile(K3S_CONFIG_DROPIN, rendered.content, 420);
-  if (!managed) {
-    result.warnings.push(ownerRestartWarning("Kubelet settings changed."));
-    return;
-  }
-  if (!mayDisrupt(ctx.runningConveyorPods)) {
-    result.warnings.push(
-      `Kubelet settings changed but ${busyReason(ctx.runningConveyorPods)} \u2014 the restart is deferred until the machine is idle.`
-    );
-    return;
-  }
-  const restart = await ctx.exec("systemctl", ["restart", "k3s"], { timeoutMs: 12e4 });
-  if (restart.exitCode === 0) {
-    result.restartedK3s = true;
-  } else {
-    result.warnings.push(
-      `Could not restart k3s to apply new kubelet settings: ${restart.stderr.trim().slice(0, 200)}`
-    );
-  }
-}
-async function reconcilePriorityClass(ctx, desired, result) {
-  const name = assertK8sName(desired.priorityClass.name, "priorityClass.name");
+async function livePriorityClassValue(ctx, name) {
   const read = await ctx.exec("k3s", [
     "kubectl",
     "get",
@@ -8836,30 +9381,59 @@ async function reconcilePriorityClass(ctx, desired, result) {
     "-o",
     "jsonpath={.value}"
   ]);
-  if (read.exitCode !== 0) return;
-  const existingValue = Number.parseInt(read.stdout.trim(), 10);
-  if (existingValue === desired.priorityClass.value) return;
+  const value = Number.parseInt(read.stdout.trim(), 10);
+  return read.exitCode === 0 && Number.isFinite(value) ? value : null;
+}
+async function reconcilePriorityClass(ctx, desired, result) {
+  const name = assertK8sName(desired.priorityClass.name, "priorityClass.name");
+  const wanted = desired.priorityClass.value;
+  const existingValue = await livePriorityClassValue(ctx, name);
+  if (existingValue === null || existingValue === wanted) return "ready";
+  if (!declaresPriorityClass(desired.rbacManifest, name, wanted)) {
+    result.warnings.push(
+      `The \`${name}\` PriorityClass has value ${existingValue}, but Conveyor's manifest does not declare it at ${wanted}, so it is left as it is. This should never happen; report it.`
+    );
+    return "kept";
+  }
   if (!mayDisrupt(ctx.runningConveyorPods)) {
     result.warnings.push(
-      `The \`${name}\` PriorityClass has value ${existingValue}, but Conveyor needs ${desired.priorityClass.value}. The value is immutable, so it must be recreated \u2014 deferred because ${busyReason(ctx.runningConveyorPods)}.`
+      `The \`${name}\` PriorityClass has value ${existingValue}, but Conveyor needs ${wanted}. The value is immutable, so it must be recreated \u2014 deferred because ${busyReason(ctx.runningConveyorPods)}.`
     );
-    return;
+    return "kept";
   }
-  const removed = await ctx.exec("k3s", ["kubectl", "delete", "priorityclass", name]);
+  const removed = await ctx.exec("k3s", [
+    "kubectl",
+    "delete",
+    "priorityclass",
+    name,
+    "--ignore-not-found"
+  ]);
   if (removed.exitCode !== 0) {
     result.warnings.push(
-      `Could not replace the \`${name}\` PriorityClass (value ${existingValue}, needs ${desired.priorityClass.value}): ${removed.stderr.trim().slice(0, 160)}`
+      `Could not replace the \`${name}\` PriorityClass (value ${existingValue}, needs ${wanted}): ${removed.stderr.trim().slice(0, 160)}`
     );
-    return;
+    return "kept";
   }
+  return "removed";
+}
+async function applyRbac(ctx, desired, result) {
+  const outcome = await reconcilePriorityClass(ctx, desired, result);
+  const manifest = outcome === "kept" ? withoutKind(desired.rbacManifest, "PriorityClass") : desired.rbacManifest;
   try {
-    await kubectlApply(ctx.exec, desired.rbacManifest);
-    result.recreatedPriorityClass = true;
+    await kubectlApply(ctx.exec, manifest);
   } catch (error) {
+    if (outcome !== "removed") throw error;
+    const value = await livePriorityClassValue(ctx, desired.priorityClass.name).catch(() => null);
+    if (value === desired.priorityClass.value) {
+      result.recreatedPriorityClass = true;
+      throw error;
+    }
     result.warnings.push(
-      `The \`${name}\` PriorityClass was removed to change its value but could not be recreated: ${error instanceof Error ? error.message : String(error)}. No build can start on this machine until it exists \u2014 run \`conveyor-k3 sync\`.`
+      `The \`${desired.priorityClass.name}\` PriorityClass was removed to change its value but could not be recreated: ${error instanceof Error ? error.message : String(error)}. No build can start on this machine until it exists \u2014 run \`conveyor-k3 sync\`.`
     );
+    return;
   }
+  if (outcome === "removed") result.recreatedPriorityClass = true;
 }
 async function step(result, label, run) {
   try {
@@ -8885,12 +9459,7 @@ async function reconcile(ctx, desired) {
       `Conveyor sent a cluster manifest containing disallowed kind(s) ${disallowedKinds.join(", ")} \u2014 refused. RBAC and PriorityClass steps skipped; this should never happen, report it.`
     );
   } else {
-    await step(result, "Could not apply RBAC", () => kubectlApply(ctx.exec, desired.rbacManifest));
-    await step(
-      result,
-      "Could not reconcile the PriorityClass",
-      () => reconcilePriorityClass(ctx, desired, result)
-    );
+    await step(result, "Could not apply RBAC", () => applyRbac(ctx, desired, result));
   }
   await step(
     result,
@@ -8922,11 +9491,23 @@ async function reconcile(ctx, desired) {
     "Could not apply kubelet settings",
     () => reconcileKubelet(ctx, desired, result, managed)
   );
+  if (desired.isolation !== void 0) {
+    await step(result, "Could not cap pod CPU", async () => {
+      result.cpuQuotaApplied = await reconcilePodCpuQuota(ctx.exec, desired, result.warnings);
+    });
+    if (desired.kubelet.systemReserved?.cpu && result.cpuQuotaApplied === void 0) {
+      result.cpuQuotaApplied = false;
+    }
+  }
   if (registry && !result.restartedK3s) {
     await step(result, "Could not load the local image registry mirror", async () => {
       if (!managed) {
         if (await registryMirrorPending(ctx.fs))
-          result.warnings.push(ownerRestartWarning("The local image registry's mirror is new."));
+          result.warnings.push(
+            ownerRestartWarning(
+              "The local image registry's mirror or credential is new, and the registry stays open to every account on this machine until k3s loads it."
+            )
+          );
         return;
       }
       const loaded = await loadRegistryMirror(ctx);
@@ -8989,6 +9570,8 @@ var ClusterDaemon = class {
    * against k3s's own settings before reporting it.
    */
   isolation = void 0;
+  /** Whether the pod slice's CPU cap is in force, from the last reconcile. */
+  cpuQuotaApplied = void 0;
   timers = [];
   /** When the last store walk started, so one that failed is not retried on every reconcile. */
   storeWalkStartedAt = 0;
@@ -9071,6 +9654,7 @@ var ClusterDaemon = class {
     );
     this.warnings = result.warnings;
     this.isolation = result.isolation;
+    this.cpuQuotaApplied = result.cpuQuotaApplied;
     this.scheduleIsolationRetry();
     for (const warning of result.warnings) this.ports.log(warning);
     if (result.prunedNamespaces.length > 0) {
@@ -9227,6 +9811,11 @@ var ClusterDaemon = class {
         );
       }
       for (const failure of result.failures) this.ports.log(`Image prune failed \u2014 ${failure}`);
+      if (result.pending.length > 0) {
+        this.ports.log(
+          `Image removal still in progress for ${result.pending.length} image(s); the next prune re-checks them.`
+        );
+      }
     } catch (error) {
       this.ports.log(
         `Skipping image prune: ${error instanceof Error ? error.message : String(error)}`
@@ -9265,6 +9854,7 @@ var ClusterDaemon = class {
         localImageHashes: this.localImageHashes,
         ...registryOn ? { localRegistry: this.registryWatch } : {},
         ...isolation.isolation ? { isolation: isolation.isolation } : {},
+        cpuQuotaApplied: this.cpuQuotaApplied,
         k3sStoreBytes: this.measuredStoreBytes
       },
       inventory
@@ -9399,55 +9989,6 @@ function renderAllUnits(options) {
   };
 }
 
-// src/lib/fs-port.ts
-import { chmod, mkdir, readFile, rm, writeFile } from "fs/promises";
-var nodeFileSystem = {
-  async readFile(path) {
-    try {
-      return await readFile(path, "utf8");
-    } catch {
-      return null;
-    }
-  },
-  async writeFile(path, content, mode) {
-    await mkdir(path.slice(0, path.lastIndexOf("/")), { recursive: true });
-    await writeFile(path, content, "utf8");
-    if (mode !== void 0) await chmod(path, mode);
-  },
-  async removeFile(path) {
-    await rm(path, { force: true });
-  },
-  async ensureDir(path, mode) {
-    await mkdir(path, { recursive: true });
-    if (mode !== void 0) await chmod(path, mode);
-  }
-};
-function createMemoryFileSystem(seed = {}) {
-  const files = new Map(Object.entries(seed));
-  const modes = /* @__PURE__ */ new Map();
-  const removed = [];
-  return {
-    files,
-    modes,
-    removed,
-    readFile: (path) => Promise.resolve(files.get(path) ?? null),
-    writeFile: (path, content, mode) => {
-      files.set(path, content);
-      if (mode !== void 0) modes.set(path, mode);
-      return Promise.resolve();
-    },
-    removeFile: (path) => {
-      files.delete(path);
-      removed.push(path);
-      return Promise.resolve();
-    },
-    ensureDir: (path, mode) => {
-      if (mode !== void 0) modes.set(path, mode);
-      return Promise.resolve();
-    }
-  };
-}
-
 // src/verbs.ts
 var VERBS = [
   "vm",
@@ -9613,17 +10154,36 @@ async function removeLocalRegistry(ports) {
       `Could not remove the local image registry from the cluster: ${removed.stderr.trim().slice(0, 200)}`
     );
   }
+  for (const [namespace, name] of [
+    [PERSONAL_LOCAL_REGISTRY_NAMESPACE, LOCAL_REGISTRY_HTPASSWD_SECRET],
+    [PERSONAL_BAKE_NAMESPACE, PERSONAL_LOCAL_REGISTRY_PUSH_SECRET]
+  ]) {
+    const secret = await ports.exec(
+      "k3s",
+      ["kubectl", "-n", namespace, "delete", "secret", name, "--ignore-not-found"],
+      { timeoutMs: 6e4 }
+    );
+    if (secret.exitCode !== 0) {
+      ports.log(
+        `Could not remove the local image registry's Secret ${namespace}/${name}: ${secret.stderr.trim().slice(0, 200)}`
+      );
+    }
+  }
   const raw = await ports.fs.readFile(REGISTRIES_FILE);
   const parsed = parseRegistries(raw);
-  if (mirrorEndpoints(parsed, PERSONAL_LOCAL_REGISTRY_HOST).length === 0) return;
+  const next = LOCAL_REGISTRY_AUTH_HOSTS.reduce(
+    removeRegistryAuth,
+    removeRegistryMirror(parsed, PERSONAL_LOCAL_REGISTRY_HOST)
+  );
+  if (serializeRegistries(next) === serializeRegistries(parsed)) return;
   const backup = await writeRegistriesWithBackup(
     ports.fs,
     raw,
-    removeRegistryMirror(parsed, PERSONAL_LOCAL_REGISTRY_HOST),
+    next,
     (ports.now ?? (() => /* @__PURE__ */ new Date()))()
   );
   ports.log(
-    `Removed the local image registry's mirror from ${REGISTRIES_FILE} (backup: ${backup}).`
+    `Removed the local image registry's mirror and credential from ${REGISTRIES_FILE} (backup: ${backup}).`
   );
 }
 async function removeIsolation(ports) {
@@ -9680,6 +10240,10 @@ async function uninstall(ports, options = {}) {
   }
   await removeLocalRegistry(ports);
   await removeIsolation(ports);
+  const lifted = await liftPodCpuQuota(ports.exec).catch(
+    (error) => error instanceof Error ? error.message : String(error)
+  );
+  if (lifted) ports.log(`Could not lift Conveyor's CPU cap on kubepods.slice: ${lifted}`);
   for (const path of OWNED_FILES) {
     await ports.fs.removeFile(path);
     result.removedFiles.push(path);
@@ -9732,6 +10296,45 @@ async function uninstall(ports, options = {}) {
   return result;
 }
 
+// src/lib/bins.ts
+var INSTALLER_PATHS = {
+  bun: "/root/.bun/bin/bun",
+  cli: "/root/.bun/bin/conveyor-k3",
+  cloudflared: "/usr/local/bin/cloudflared"
+};
+var CLI_PATH_LINK = "/usr/local/bin/conveyor-k3";
+async function linkCliOnPath(exec, target = INSTALLER_PATHS.cli) {
+  if (target === CLI_PATH_LINK) return { linked: false };
+  const present = await exec("test", ["-x", target]).catch(() => null);
+  if (present?.exitCode !== 0) return { linked: false };
+  const link = await exec("ln", ["-sfn", target, CLI_PATH_LINK]).catch(() => null);
+  if (link?.exitCode === 0) return { linked: true };
+  return {
+    linked: false,
+    problem: `Could not link ${CLI_PATH_LINK} to ${target}: ${link?.stderr.trim().slice(0, 200) || "ln failed"}`
+  };
+}
+
+// src/lib/cloudflared.ts
+var PACKAGE_MANAGER_REFUSAL = "installed by a package manager";
+async function resolveRealPath(exec, bin) {
+  const result = await exec("readlink", ["-f", bin]).catch(() => null);
+  const resolved = result?.exitCode === 0 ? result.stdout.trim() : "";
+  return resolved.startsWith("/") ? resolved : bin;
+}
+async function cloudflaredUpdater(exec, bin) {
+  const real = await resolveRealPath(exec, bin);
+  const owner = await exec("dpkg", ["-S", real]).catch(() => null);
+  return owner?.exitCode === 0 ? "package-manager" : "conveyor";
+}
+function isPackageManagerRefusal(output) {
+  return `${output.stdout}
+${output.stderr}`.toLowerCase().includes(PACKAGE_MANAGER_REFUSAL);
+}
+function describeCloudflaredUpdater(updater) {
+  return updater === "package-manager" ? "cloudflared is updated by your package manager, not by Conveyor" : "cloudflared is updated by Conveyor's daily update";
+}
+
 // src/commands/update.ts
 var CLOUDFLARED_UPDATED_EXIT = 11;
 function readExecStart(unit) {
@@ -9819,7 +10422,22 @@ async function updatePackage(ports, result, targetVersion) {
   await ports.exec("systemctl", ["restart", DAEMON_UNIT]);
 }
 async function updateCloudflared(ports, result) {
+  const packaged = () => {
+    result.cloudflaredUpdater = "package-manager";
+    result.notes.push(
+      `cloudflared update skipped: ${describeCloudflaredUpdater("package-manager")}`
+    );
+  };
+  if (await cloudflaredUpdater(ports.exec, ports.bins.cloudflared) === "package-manager") {
+    packaged();
+    return;
+  }
   const update = await ports.exec(ports.bins.cloudflared, ["update"], { timeoutMs: 5 * 6e4 });
+  if (isPackageManagerRefusal(update)) {
+    packaged();
+    return;
+  }
+  result.cloudflaredUpdater = "conveyor";
   if (update.exitCode !== CLOUDFLARED_UPDATED_EXIT) return;
   result.cloudflaredUpdated = true;
   ports.log("cloudflared was updated; restarting the tunnel.");
@@ -9829,10 +10447,13 @@ async function runUpdate(ports, decision, channel, targetVersion) {
   const result = {
     packageUpdated: false,
     cloudflaredUpdated: false,
+    cloudflaredUpdater: null,
     k3sUpgraded: false,
     notes: []
   };
   await updatePackage(ports, result, targetVersion);
+  const linked = await linkCliOnPath(ports.exec);
+  if (linked.problem) result.notes.push(linked.problem);
   await updateCloudflared(ports, result);
   if (!decision.upgrade) {
     result.notes.push(`k3s upgrade skipped: ${decision.reason}`);
@@ -9865,6 +10486,9 @@ async function runUpdate(ports, decision, channel, targetVersion) {
   return result;
 }
 
+// src/lib/env.ts
+import { readFileSync as readFileSync3 } from "fs";
+
 // src/commands/setup.ts
 var K3S_MIN_MAJOR_MINOR = [1, 29];
 function parseK3sVersion(output) {
@@ -10868,7 +11492,6 @@ export {
   renderAllUnits,
   renderGuestDnsProvision,
   renderK3sDropIn,
-  renderKubeletDropIn,
   renderRegistryAuthSummary,
   resolveCloudflaredSrvRecords,
   resolveNetwork,