@outerlayer/cli 0.7.0 → 0.8.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @outerlayer/cli
 
+## 0.8.0
+
+### Minor Changes
+
+- 8da1a39: The runner now builds every image in a Buildx builder of its own, whose container has a memory limit of `runner.build.memory`. A recipe step that uses more memory is stopped, and the build is released failed at provision with a reason that names the limit. Hosts need Docker's Buildx plugin (`docker-buildx-plugin`, version 0.18 or later); a host without it claims no work, and `outerlayer doctor` fails an "Image build limit" check that names the package. Housekeeping now trims the runner's builder cache, not Docker's default builder.
+
+  `outerlayer runner install`, `runner install --service` and `runner init` also write `~/.local/bin/outerlayer`, a launcher that runs the CLI in the runner's `current` link, so the command on PATH follows a self-update. `runner install --replace` replaces a launcher file the runner did not write.
+
+### Patch Changes
+
+- 983c221: A build whose clone fails now says why: the release reason ends with the fatal or error line git printed, not only its exit status.
+- 5a7ca29: The README now says the `OuterLayer evidence` check on GitHub completes once the automated checks pass, without waiting for a person's review in OuterLayer. It also gives the `review` policy key's default correctly as `required`.
+- 628c6c9: A `builtin:vm` build's host checks now run in a new microVM booted from the build's image, where they used to always fail.
+- c2a0315: `outerlayer runner init --vm` sizes the VM's disk with room for the free-disk minimum and the Docker build cache, so the runner in the VM keeps claiming work once its disk fills. With the default limits the disk is 90 GiB, allocated as it is used.
+- 983c221: On WSL2, `outerlayer runner install --service` makes no scheduled task when `WSL_DISTRO_NAME` is unset, as under `sudo`, and prints the `schtasks` command to run instead. It no longer guesses `Ubuntu`, which made a task that started nothing.
+
 ## 0.7.0
 
 ### Minor Changes

package/README.md

@@ -413,11 +413,11 @@ pass or fail on an item that is closed or shipped, has no evaluation yet,
 or whose evaluation is still waiting on a session link, with the code
 `not_reviewable`. A recorded pass on the general thread carries the head
 commit of every pull request the item had at the time; once one of them
-moves, that pass stops counting and a fresh review is needed. A repository
-can require a current pass before the evidence check completes by setting
-the base branch's `review` policy key to `required` (default `optional`,
-alongside `merge_gate`) — the check then stays in progress, not failed,
-until a current pass exists.
+moves, that pass stops counting and a fresh review is needed. The base
+branch's `review` policy key (default `required`, beside `merge_gate`)
+holds the item at "Awaiting a person's review" until a current pass
+exists. The evidence check on GitHub does not wait for that review: it
+completes once the automated checks pass and says the review is pending.
 
 A criterion thread is scoped to one acceptance criterion rather than the
 whole item: an agent attaches proof with `outerlayer work comment

package/dist/{build-JF5UOWKJ.js → build-MS34XEGN.js}

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-export { buildRepositoryImage } from './chunk-CEBIA5FD.js';
+export { buildRepositoryImage } from './chunk-TTNFGMHO.js';
 import './chunk-N5FOE5PS.js';
 export { RecipeError } from './chunk-QOZKPLVJ.js';
+import './chunk-CX22S5BA.js';
 import './chunk-HKMPVPO7.js';
 import './chunk-ZM2IMMYN.js';
 import './chunk-Z5GEFMRW.js';

package/dist/build-info.json

@@ -1 +1 @@
-{"id":"2026-10-05T00:52:06.865Z+90312df","root":"/home/runner/_work/outerlayer/outerlayer","pkg":"outerlayer"}
+{"id":"2026-10-05T12:31:55.812Z+ff35a38","root":"/home/runner/_work/outerlayer/outerlayer","pkg":"outerlayer"}

package/dist/builder-G52A6GW2.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+export { MIN_BUILDX_VERSION, builderName, builderSpec, buildxState, ensureBuilder, ensureFailureCount, isOutOfMemory, proxyEnvironment, trackImageBuild } from './chunk-5TNS3PL7.js';
+import './chunk-CX22S5BA.js';
+import './chunk-GAYWY4GI.js';
+import './chunk-7RQ73DLO.js';
+import './chunk-OD2VTIHN.js';
+import './chunk-HKMPVPO7.js';
+import './chunk-YNJEOGDL.js';
+import './chunk-ZM2IMMYN.js';
+import './chunk-Z5GEFMRW.js';
+
+createRequire(import.meta.url);

package/dist/{check-ASZL5BEO.js → check-FOF3PUKI.js}

@@ -1,43 +1,46 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { probeCredentials } from './chunk-AII7CKTH.js';
+import { probeCredentials } from './chunk-IJBVPLZZ.js';
 import './chunk-ABIWDUMS.js';
-import './chunk-TI7B7UEO.js';
-import './chunk-AJKEHABI.js';
+import './chunk-7VNURP6M.js';
 import './chunk-T6OIJQRT.js';
 import './chunk-AIW6GLET.js';
 import './chunk-UGP76IZ5.js';
-import './chunk-2VO25HHO.js';
+import './chunk-3S4P55NE.js';
 import './chunk-WVGSB3Z2.js';
-import './chunk-6ZZHWY2Z.js';
+import './chunk-AIL2R4SI.js';
 import './chunk-HHJDN6AU.js';
-import { placeholderQueues, placeholderProblem, needsClaudeCredential, claudeCredentialCheck, claimPermissionProblem } from './chunk-6IYLDODX.js';
+import { placeholderQueues, placeholderProblem, needsClaudeCredential, claudeCredentialCheck, claimPermissionProblem } from './chunk-IRCBTGWF.js';
+import './chunk-TI7B7UEO.js';
 import './chunk-YYYRBYWG.js';
 import './chunk-TBT347UY.js';
-import './chunk-6QWV3YDJ.js';
-import './chunk-OUUINEYB.js';
-import './chunk-AQ54MKSQ.js';
-import './chunk-E4PIFIC3.js';
-import './chunk-CEBIA5FD.js';
+import './chunk-NALVDFIS.js';
+import './chunk-TUUMW4TC.js';
+import './chunk-CM5QTKM4.js';
+import './chunk-JKIWMRFH.js';
+import './chunk-TTNFGMHO.js';
 import './chunk-N5FOE5PS.js';
 import './chunk-OGFGZQA3.js';
-import './chunk-774HEQL6.js';
+import './chunk-U3GOI2B4.js';
 import './chunk-QOZKPLVJ.js';
+import './chunk-5TNS3PL7.js';
+import './chunk-CX22S5BA.js';
 import './chunk-ZOAEPWGL.js';
 import './chunk-R7STSBLC.js';
 import './chunk-F7CU5ABH.js';
 import './chunk-BKO6JEZI.js';
-import './chunk-DGAIVMMN.js';
-import './chunk-PUN7LMNS.js';
+import './chunk-5QLNZGAQ.js';
+import './chunk-4ACZCY4I.js';
 import './chunk-BFESLKPP.js';
-import './chunk-SSU747O6.js';
+import './chunk-ILEA3YHM.js';
 import './chunk-ZYHKJKSU.js';
-import './chunk-D6FXM5OW.js';
+import './chunk-GAYWY4GI.js';
 import './chunk-USO2DKBD.js';
 import './chunk-N6LURUEF.js';
 import './chunk-YRYMNBGQ.js';
-import { loadRunnerConfig, RunnerConfigError, checkHooks } from './chunk-DTXOJDEH.js';
-import './chunk-F6GFZXZ3.js';
+import { loadRunnerConfig, RunnerConfigError, checkHooks } from './chunk-PWBILI5P.js';
+import './chunk-UXYLWVTQ.js';
+import './chunk-7RQ73DLO.js';
 import './chunk-OD2VTIHN.js';
 import './chunk-HKMPVPO7.js';
 import './chunk-GQD22KKN.js';

package/dist/{chunk-2VO25HHO.js → chunk-3S4P55NE.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { LiveUploader } from './chunk-6ZZHWY2Z.js';
-import { CaptureDaemon } from './chunk-D6FXM5OW.js';
+import { LiveUploader } from './chunk-AIL2R4SI.js';
+import { CaptureDaemon } from './chunk-GAYWY4GI.js';
 import { parseWorkItemEnv } from './chunk-GQD22KKN.js';
 import { spoolDir } from './chunk-JPR2WHHF.js';
 import { homeFromEnv } from './chunk-VNVZDWO3.js';

package/dist/{chunk-MQPRB5K7.js → chunk-4A5E2G4E.js}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
 import { readStatuslineState, STATE_FRESH_MS } from './chunk-F47JBIAW.js';
-import { resolveCredentials, getJson, WorkCommandError } from './chunk-DGAIVMMN.js';
-import { isLinkedRepository } from './chunk-SSU747O6.js';
+import { resolveCredentials, getJson, WorkCommandError } from './chunk-5QLNZGAQ.js';
+import { isLinkedRepository } from './chunk-ILEA3YHM.js';
 import { sanitizeTerminal } from './chunk-ZYHKJKSU.js';
-import { resolveRepoIdentity, compareVersions, SUPPORTED_VERSIONS } from './chunk-D6FXM5OW.js';
+import { resolveRepoIdentity, compareVersions, SUPPORTED_VERSIONS } from './chunk-GAYWY4GI.js';
 import { C } from './chunk-YRYMNBGQ.js';
 import { readSettings, settingsPath, isOurStatuslineSlot, statuslineWrappedOriginal, REGISTERED_EVENTS, isOurHookCommand, ourCommandBins, cliBinResolvable, ourDirectScriptBins, wrappedOriginalCommand } from './chunk-5QRP3MVS.js';
 import { readPin, readContextManifest, readDegraded, readSourceCache } from './chunk-ZZXLM64C.js';
@@ -1004,7 +1004,7 @@ function doctorExitCode(checks) {
 
 // src/doctor-report.ts
 async function gatherDoctorChecks() {
-  const { defaultRunnerConfigPath, hasRunnerBlock, loadRunnerConfig, runnerVmOf } = await import('./config-I3TVFYLH.js');
+  const { defaultRunnerConfigPath, hasRunnerBlock, loadRunnerConfig, runnerVmOf } = await import('./config-Z3USDBLU.js');
   const configPath = defaultRunnerConfigPath();
   const checks = runDoctor({ runnerHost: hasRunnerBlock(configPath) });
   const credential = await credentialChecks();
@@ -1016,7 +1016,7 @@ async function gatherDoctorChecks() {
     const { runnerVmCheck } = await import('./doctor-53F2PYY7.js');
     checks.push(runnerVmCheck(configPath, { lima: realLima(), home: homeFromEnv(), instance: runnerVm.instance }));
   } else if (hasRunnerBlock(configPath)) {
-    const { runnerHostChecks } = await import('./doctor-FVDT3KJZ.js');
+    const { runnerHostChecks } = await import('./doctor-WR6TRPSU.js');
     const hooks = (() => {
       try {
         return loadRunnerConfig(configPath).hooks;
@@ -1051,7 +1051,7 @@ async function gatherDoctorChecks() {
       const { existsSync: existsSync2 } = await import('fs');
       if (process.platform !== "linux" || !existsSync2("/run/systemd/system")) return void 0;
       const { inspectService, realInspectProbes } = await import('./inspect-XAUSB7L3.js');
-      const { DEFAULT_UNIT_NAME } = await import('./install-NMAPLLBQ.js');
+      const { DEFAULT_UNIT_NAME } = await import('./install-FHTVJZS6.js');
       const { dirname: dirname2 } = await import('path');
       return inspectService(DEFAULT_UNIT_NAME, dirname2(configPath), realInspectProbes());
     })();

package/dist/{chunk-PUN7LMNS.js → chunk-4ACZCY4I.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { fetchFactories, selectFactory, saveFactoryConnection, connectedLine } from './chunk-SSU747O6.js';
-import { resolveRepoIdentity } from './chunk-D6FXM5OW.js';
+import { fetchFactories, selectFactory, saveFactoryConnection, connectedLine } from './chunk-ILEA3YHM.js';
+import { resolveRepoIdentity } from './chunk-GAYWY4GI.js';
 import { resolveGatewayCredentials } from './chunk-BOLTI6LR.js';
 import { findGitDirs, readRepoConnection } from './chunk-BJ3KTMDH.js';
 import { homeFromEnv } from './chunk-VNVZDWO3.js';

package/dist/{chunk-DGAIVMMN.js → chunk-5QLNZGAQ.js}

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { autoConnect } from './chunk-PUN7LMNS.js';
+import { autoConnect } from './chunk-4ACZCY4I.js';
 import { detectActiveSession } from './chunk-BFESLKPP.js';
 import { sanitizeTerminal } from './chunk-ZYHKJKSU.js';
-import { resolveRepoIdentity } from './chunk-D6FXM5OW.js';
+import { resolveRepoIdentity } from './chunk-GAYWY4GI.js';
 import { parseTrackerNumber, trackerNumberError } from './chunk-WZBHBH3J.js';
 import { defaultFetch } from './chunk-BCLJSQCV.js';
 import { resolveGatewayCredentials, unauthorizedMessage } from './chunk-BOLTI6LR.js';

package/dist/chunk-5TNS3PL7.js

@@ -0,0 +1,263 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { BUILDKIT_IMAGE } from './chunk-CX22S5BA.js';
+import { compareVersions } from './chunk-GAYWY4GI.js';
+import { parseSize } from './chunk-7RQ73DLO.js';
+import { JOB_MOUNT, GATEWAY_PORT, GATEWAY_SOCKET, CLAUDE_PORT, CLAUDE_SOCKET, RELAY_PORT, DESTINATION_BASE_PORT } from './chunk-OD2VTIHN.js';
+import { runnerDir } from './chunk-ZM2IMMYN.js';
+import { createHash } from 'crypto';
+import { realpathSync } from 'fs';
+import { join, dirname, resolve } from 'path';
+
+createRequire(import.meta.url);
+var BUILD_LABEL = "ai.outerlayer.build";
+var RUNNER_LABEL = "ai.outerlayer.runner";
+function resolvedRunnerDir(configPath) {
+  try {
+    return realpathSync(runnerDir(configPath));
+  } catch {
+    try {
+      return join(realpathSync(dirname(resolve(configPath))), "runner");
+    } catch {
+      return resolve(runnerDir(configPath));
+    }
+  }
+}
+function runnerLabelValue(configPath) {
+  return createHash("sha256").update(resolvedRunnerDir(configPath)).digest("hex").slice(0, 12);
+}
+function hardened(input) {
+  const { memory, cpus, pids } = input.limits;
+  return [
+    "--label",
+    `${BUILD_LABEL}=${input.buildId}`,
+    "--label",
+    `${RUNNER_LABEL}=${input.runnerId}`,
+    "--network",
+    "none",
+    "--cap-drop",
+    "ALL",
+    "--security-opt",
+    "no-new-privileges",
+    "--read-only",
+    "--user",
+    input.user,
+    // The same figure for swap as for memory leaves the container none.
+    "--memory",
+    memory,
+    "--memory-swap",
+    memory,
+    "--cpus",
+    String(cpus),
+    "--pids-limit",
+    String(pids)
+  ];
+}
+function mountPath(path) {
+  if (/[",]/.test(path)) throw new Error(`${path} holds a comma or a quote, which a Docker mount cannot carry; move the runner's config file`);
+  return path;
+}
+function containerRunArgs(input) {
+  return [
+    "--detach",
+    "--name",
+    input.container,
+    ...hardened(input),
+    "--mount",
+    `type=volume,src=${input.volume},dst=/build`,
+    // `/tmp` is a directory of the same volume, so it is measured and limited with the rest of the build.
+    "--mount",
+    `type=volume,src=${input.volume},dst=/tmp,volume-subpath=tmp`,
+    "--mount",
+    `type=bind,src=${mountPath(input.buildDir)},dst=${JOB_MOUNT},readonly`,
+    "--entrypoint",
+    "/opt/outerlayer/bin/tini",
+    input.image,
+    "--",
+    "/opt/outerlayer/bin/node",
+    "/opt/outerlayer/cli/dist/index.js",
+    "broker-relay",
+    "--port",
+    String(RELAY_PORT),
+    "--socket",
+    `${JOB_MOUNT}/tunnel.sock`,
+    ...Array.from({ length: input.destinations ?? 0 }, (_unused, index) => [
+      "--forward",
+      `${DESTINATION_BASE_PORT + index}=${JOB_MOUNT}/dest-${index}.sock`
+    ]).flat(),
+    ...input.builtIns === true ? [
+      "--forward",
+      `${GATEWAY_PORT}=${JOB_MOUNT}/${GATEWAY_SOCKET}`,
+      "--forward",
+      `${CLAUDE_PORT}=${JOB_MOUNT}/${CLAUDE_SOCKET}`
+    ] : []
+  ];
+}
+function prepareRunArgs(input) {
+  return [
+    "--rm",
+    ...hardened(input),
+    "--mount",
+    `type=volume,src=${input.volume},dst=/build`,
+    "--entrypoint",
+    "mkdir",
+    input.image,
+    "-p",
+    "-m",
+    "1777",
+    "/build/tmp",
+    "/build/home",
+    "/build/work"
+  ];
+}
+function containerExecArgs(input) {
+  const literals = Object.keys(input.env.literals).sort().flatMap((name) => ["-e", `${name}=${input.env.literals[name]}`]);
+  const passed = Object.keys(input.env.passed).filter((name) => input.env.passed[name] !== void 0).sort().flatMap((name) => ["-e", name]);
+  return [
+    "-u",
+    input.user,
+    ...input.workdir === void 0 ? [] : ["-w", input.workdir],
+    ...literals,
+    ...passed,
+    input.container,
+    ...input.argv
+  ];
+}
+
+// src/runner/image/builder.ts
+var MIN_BUILDX_VERSION = "0.18.0";
+var INSTALL_HINT = "install Docker's Buildx plugin (docker-buildx-plugin on Debian and Ubuntu with Docker's apt repository, docker-buildx on Ubuntu's own packages)";
+function builderName(configPath) {
+  return `outerlayer-${runnerLabelValue(configPath)}`;
+}
+function proxyEnvironment(env) {
+  const found = {};
+  for (const name of ["HTTP_PROXY", "HTTPS_PROXY", "NO_PROXY", "http_proxy", "https_proxy", "no_proxy"]) {
+    const value = env[name];
+    if (value !== void 0 && value !== "") found[name] = value;
+  }
+  return found;
+}
+function builderSpec(configPath, memory, env) {
+  return { name: builderName(configPath), memory, env: proxyEnvironment(env) };
+}
+function driverOpt(pair) {
+  return /[",]/.test(pair) ? `"${pair.replace(/"/g, '""')}"` : pair;
+}
+async function buildxState(run) {
+  const result = await run("docker", ["buildx", "version"]);
+  if (result.status !== 0) {
+    const said = (result.stderr.trim() || result.stdout.trim()).split("\n")[0] ?? "";
+    return { problem: `docker buildx is not available${said === "" ? "" : ` (${said})`}, so image builds cannot be limited; ${INSTALL_HINT}` };
+  }
+  const version = /\bv?(\d+\.\d+\.\d+)/.exec(result.stdout)?.[1];
+  if (version !== void 0 && compareVersions(version, MIN_BUILDX_VERSION) < 0) {
+    return { problem: `docker buildx ${version} is too old: the runner's image builder needs Buildx ${MIN_BUILDX_VERSION} or later; update ${INSTALL_HINT}` };
+  }
+  return "usable";
+}
+function isOutOfMemory(output) {
+  if (/cannot allocate memory/i.test(output)) return true;
+  if (/did not complete successfully: (exit code: 137|signal: killed)/i.test(output)) return true;
+  return /ResourceExhausted/i.test(output) && !/larger than max|message size|too large/i.test(output);
+}
+var running = 0;
+async function trackImageBuild(work) {
+  running++;
+  try {
+    return await work();
+  } finally {
+    running--;
+  }
+}
+var queue = Promise.resolve();
+function serialized(work) {
+  const next = queue.then(work, work);
+  queue = next.catch(() => void 0);
+  return next;
+}
+function readExisting(inspectOutput) {
+  const options = /^Driver Options:\s*(.*)$/m.exec(inspectOutput)?.[1] ?? "";
+  const option = (key) => new RegExp(`(?:^|\\s)${key}="([^"]*)"`).exec(options)?.[1];
+  return { driver: /^Driver:\s*(\S+)/m.exec(inspectOutput)?.[1], memory: option("memory"), image: option("image") };
+}
+function sameMemory(found, wanted) {
+  return (parseSize(found) ?? found) === (parseSize(wanted) ?? wanted);
+}
+var IDLE_POLL_MS = 1e3;
+var failures = 0;
+function ensureFailureCount() {
+  return failures;
+}
+function ensureBuilder(rawRun, spec, options = {}) {
+  const run = (command, args, opts) => rawRun(command, args, { ...opts, timeoutMs: args.includes("--bootstrap") ? 15 * 6e4 : 2 * 6e4 });
+  const result = serialized(async () => {
+    const state = await buildxState(run);
+    if (state !== "usable") return { ok: false, problem: state.problem };
+    const sleep = options.sleep ?? ((ms) => new Promise((resolve2) => setTimeout(resolve2, ms)));
+    const inspected = await run("docker", ["buildx", "inspect", spec.name]);
+    let create = inspected.status !== 0;
+    if (!create) {
+      const found = readExisting(inspected.stdout);
+      const current = found.driver === "docker-container" && sameMemory(found.memory ?? "", spec.memory) && found.image === BUILDKIT_IMAGE;
+      if (!current && options.replaceStale === false) {
+        return {
+          ok: false,
+          problem: `the image builder ${spec.name} was made with other settings than runner.build.memory (${spec.memory}) and the pinned BuildKit image; the runner service replaces it when no build is running, or remove it with docker buildx rm ${spec.name}`
+        };
+      }
+      if (!current) {
+        if (options.waitForIdle === true) while (running > 0) await sleep(IDLE_POLL_MS);
+        if (running === 0) {
+          const removed = await run("docker", ["buildx", "rm", spec.name]);
+          if (removed.status !== 0) return { ok: false, problem: `could not replace the image builder ${spec.name}: ${removed.stderr.trim() || `docker exited ${removed.status}`}` };
+          create = true;
+        }
+      }
+    }
+    if (create) {
+      const opts = [
+        `memory=${spec.memory}`,
+        `memory-swap=${spec.memory}`,
+        `image=${BUILDKIT_IMAGE}`,
+        ...Object.entries(spec.env ?? {}).map(([name, value]) => `env.${name}=${value}`),
+        ...spec.driverOpts ?? []
+      ];
+      const created = await run("docker", [
+        "buildx",
+        "create",
+        "--name",
+        spec.name,
+        "--driver",
+        "docker-container",
+        ...opts.flatMap((opt) => ["--driver-opt", driverOpt(opt)])
+      ]);
+      if (created.status !== 0) {
+        const said = created.stderr.trim() || `docker exited ${created.status}`;
+        if (/failed to find driver/i.test(said)) {
+          return { ok: false, problem: `this Docker's Buildx has no docker-container driver, so image builds cannot be limited; ${INSTALL_HINT}` };
+        }
+        return { ok: false, problem: `could not create the image builder ${spec.name}: ${said}` };
+      }
+    }
+    if (options.bootstrap === true) {
+      const started = await run("docker", ["buildx", "inspect", "--bootstrap", spec.name]);
+      if (started.status !== 0) {
+        return { ok: false, problem: `the image builder ${spec.name} did not start: ${started.stderr.trim() || `docker exited ${started.status}`}` };
+      }
+    }
+    return { ok: true, changed: create };
+  });
+  return result.then(
+    (outcome) => {
+      if (!outcome.ok) failures++;
+      return outcome;
+    },
+    (err) => {
+      failures++;
+      throw err;
+    }
+  );
+}
+
+export { BUILD_LABEL, MIN_BUILDX_VERSION, RUNNER_LABEL, builderName, builderSpec, buildxState, containerExecArgs, containerRunArgs, ensureBuilder, ensureFailureCount, isOutOfMemory, prepareRunArgs, proxyEnvironment, runnerLabelValue, trackImageBuild };

package/dist/chunk-7RQ73DLO.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+
+createRequire(import.meta.url);
+
+// src/runner/container/disk.ts
+var UNITS = { "": 1, k: 1024, m: 1024 ** 2, g: 1024 ** 3 };
+function parseSize(text) {
+  const match = /^(\d+(?:\.\d+)?)([kKmMgG]?)$/.exec(text);
+  if (match === null) return void 0;
+  const bytes = Number(match[1]) * UNITS[match[2].toLowerCase()];
+  return bytes > 0 ? bytes : void 0;
+}
+function parseDuKilobytes(output) {
+  const match = /^(\d+)\s/.exec(output);
+  return match === null ? void 0 : Number(match[1]);
+}
+function exceedsDisk(usedKilobytes, limit) {
+  const bytes = parseSize(limit);
+  return usedKilobytes * 1024 > (bytes ?? Number.POSITIVE_INFINITY);
+}
+
+export { exceedsDisk, parseDuKilobytes, parseSize };