@outerlayer/cli 0.6.0 → 0.8.0

package/dist/{chunk-RZSF5B46.js → chunk-CM5QTKM4.js}

@@ -1,24 +1,27 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { readDefaultBranchHead, cloneRepository, buildRepositoryImage, CLAUDE_CODE_VERSION, firecrackerArch, MICROVM_ARCHES, DEFAULT_BASE_IMAGE, GUEST_HELPER_SHA256, GUEST_ASSETS_BASE_URL, GUEST_KERNEL_SHA256, FIRECRACKER_BINARY_SHA256, FIRECRACKER_SHA256, FIRECRACKER_VERSION, GUEST_ASSETS_VERSION } from './chunk-Z62HNKEJ.js';
+import { readDefaultBranchHead, cloneRepository, buildRepositoryImage } from './chunk-TTNFGMHO.js';
 import { startTimeOf, isSameProcess } from './chunk-N5FOE5PS.js';
 import { currentCliBuild } from './chunk-OGFGZQA3.js';
-import { createDockerHost, childEnvironment, spawnRun } from './chunk-774HEQL6.js';
+import { createDockerHost, childEnvironment, spawnRun } from './chunk-U3GOI2B4.js';
 import { RecipeError } from './chunk-QOZKPLVJ.js';
-import { execCapture } from './chunk-W4SQCOZU.js';
-import { GUEST_CID } from './chunk-B2G7JHHB.js';
-import { WorkCommandError, postJson } from './chunk-BNMCXPG7.js';
-import { parseDuKilobytes, hostAllowed } from './chunk-F6GFZXZ3.js';
-import { RELAY_PORT, CHECKOUT_DIR, JOB_MOUNT, claudeCredential, buildEnvironment, startBuildServices, AGENT_CREDENTIAL_MISSING, GATEWAY_PORT, GATEWAY_SOCKET, CLAUDE_PORT, CLAUDE_SOCKET, DESTINATION_BASE_PORT } from './chunk-AUFG23AA.js';
-import { defaultGitRunner, materializeContext } from './chunk-OIRNH6UO.js';
-import { readContextManifest, readSourceCache } from './chunk-WIOZAJ2W.js';
+import { builderSpec, runnerLabelValue, RUNNER_LABEL, BUILD_LABEL, prepareRunArgs, containerRunArgs, containerExecArgs } from './chunk-5TNS3PL7.js';
+import { CLAUDE_CODE_VERSION, firecrackerArch, MICROVM_ARCHES, DEFAULT_BASE_IMAGE, GUEST_HELPER_SHA256, GUEST_ASSETS_BASE_URL, GUEST_KERNEL_SHA256, FIRECRACKER_BINARY_SHA256, FIRECRACKER_SHA256, FIRECRACKER_VERSION, GUEST_ASSETS_VERSION } from './chunk-CX22S5BA.js';
+import { execCapture } from './chunk-ZOAEPWGL.js';
+import { GUEST_CID } from './chunk-R7STSBLC.js';
+import { WorkCommandError, postJson } from './chunk-5QLNZGAQ.js';
+import { hostAllowed } from './chunk-UXYLWVTQ.js';
+import { parseDuKilobytes } from './chunk-7RQ73DLO.js';
+import { RELAY_PORT, CHECKOUT_DIR, JOB_MOUNT, claudeCredential, buildEnvironment, startBuildServices, checkEnvironment, AGENT_CREDENTIAL_MISSING } from './chunk-OD2VTIHN.js';
+import { defaultGitRunner, materializeContext } from './chunk-5FWNEQNZ.js';
+import { readContextManifest, readSourceCache } from './chunk-ZZXLM64C.js';
 import { signingFetchFor } from './chunk-BCLJSQCV.js';
 import { signerFor } from './chunk-M5POMKKW.js';
-import { rootfsPathFor, diskTemplatesDir, RUNNER_FILE_MODE, stagedContextDir, contextHomeDir, ghConfigDir, runnerDirOfBuild, spoolDir, mirrorDir, buildDir, runnerDir, RUNNER_DIR_MODE, vmAssetsDir } from './chunk-ZM2IMMYN.js';
-import { relative, join, dirname, resolve, basename } from 'path';
-import { readFileSync, existsSync, mkdirSync, chmodSync, truncateSync, rmSync, writeFileSync, accessSync, constants, readdirSync, statSync, rmdirSync, realpathSync, renameSync, lstatSync, unlinkSync, openSync, closeSync, mkdtempSync, createWriteStream, createReadStream } from 'fs';
+import { rootfsPathFor, diskTemplatesDir, RUNNER_FILE_MODE, stagedContextDir, contextHomeDir, ghConfigDir, runnerDirOfBuild, spoolDir, mirrorDir, buildDir, RUNNER_DIR_MODE, vmAssetsDir } from './chunk-ZM2IMMYN.js';
+import { relative, join, dirname, basename } from 'path';
+import { readFileSync, existsSync, mkdirSync, chmodSync, truncateSync, rmSync, writeFileSync, accessSync, constants, readdirSync, statSync, rmdirSync, renameSync, lstatSync, unlinkSync, openSync, closeSync, mkdtempSync, createWriteStream, createReadStream } from 'fs';
 import { spawnSync, spawn } from 'child_process';
-import { createHash, randomBytes } from 'crypto';
+import { randomBytes, createHash } from 'crypto';
 import { createServer, request } from 'http';
 import { request as request$1 } from 'https';
 import { Transform } from 'stream';
@@ -86,7 +89,7 @@ function isRetryable(err) {
 }
 async function retrySend(send, deps = {}) {
   const now = deps.now ?? (() => /* @__PURE__ */ new Date());
-  const sleep = deps.sleep ?? ((ms) => new Promise((resolve2) => setTimeout(resolve2, ms)));
+  const sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
   const windowMs = deps.windowMs ?? RETRY_WINDOW_MS;
   const startedMs = now().getTime();
   let attempts = 0;
@@ -283,12 +286,14 @@ function prepareRunnerCgroup(setup) {
   fs.write(join(root, "cgroup.subtree_control"), "+memory");
   return { root };
 }
+var BUILD_RECLAIM_HEADROOM_BYTES = 256 * 1024 ** 2;
+var BUILD_KILL_HEADROOM_BYTES = 1024 ** 3;
 function createBuildCgroup(fs, root, buildId, buildMemoryBytes) {
   const path = join(root, `${BUILD_PREFIX}${buildId}`);
-  const firecrackerOverheadBytes = 256 * 1024 ** 2;
   fs.mkdir(path);
   try {
-    fs.write(join(path, "memory.max"), String(buildMemoryBytes + firecrackerOverheadBytes));
+    fs.write(join(path, "memory.high"), String(buildMemoryBytes + BUILD_RECLAIM_HEADROOM_BYTES));
+    fs.write(join(path, "memory.max"), String(buildMemoryBytes + BUILD_KILL_HEADROOM_BYTES));
     fs.write(join(path, "memory.swap.max"), "0");
   } catch (err) {
     removeBuildCgroup(fs, path);
@@ -296,6 +301,9 @@ function createBuildCgroup(fs, root, buildId, buildMemoryBytes) {
   }
   return path;
 }
+function outOfMemoryReason(memory) {
+  return `the build ran out of memory: the kernel killed its microVM at the limit of runner.build.memory (${memory ?? "8g"}) plus 1 GiB for Firecracker and its disks' page cache. Raise runner.build.memory, or lower runner.concurrency`;
+}
 function oomKills(fs, path) {
   const match = /^oom_kill (\d+)$/m.exec(fs.read(join(path, "memory.events")) ?? "");
   return match === null ? 0 : Number(match[1]);
@@ -461,119 +469,6 @@ function lifecycleSteps(lifecycle) {
 function lifecycleFailureReason(step, exitCode) {
   return `lifecycle command ${step.name} (${step.source}) exited ${exitCode}`;
 }
-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(),
-    ...[
-      "--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
-  ];
-}
 var AssetError = class extends Error {
   constructor(file, message) {
     super(message);
@@ -714,7 +609,7 @@ function converterArgs(dest, extra, script) {
 }
 var firstLine2 = (text) => text.trim().split("\n")[0] ?? "";
 function exportInto(container, converter) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve, reject) => {
     const exporter = spawn("docker", ["export", container], { stdio: ["ignore", "pipe", "pipe"], env: childEnvironment(process.env) });
     const writer = spawn("docker", converter, { stdio: ["pipe", "ignore", "pipe"], env: childEnvironment(process.env) });
     const errors = [];
@@ -731,7 +626,7 @@ function exportInto(container, converter) {
       if (code !== 0 && failure === void 0) failure = `${name} exited ${code}`;
       exits += 1;
       if (exits < 2) return;
-      if (failure === void 0) resolve2();
+      if (failure === void 0) resolve();
       else reject(new Error(`${failure}: ${firstLine2(errors.join("\n"))}`));
     };
     exporter.once("exit", (code) => done("docker export", code));
@@ -880,7 +775,7 @@ function createFirecrackerHost(options = {}) {
         const failed = new Promise((_resolve, reject) => child.once("error", reject));
         const pid = child.pid;
         if (pid === void 0) return await failed;
-        exits.set(pid, new Promise((resolve2) => child.once("exit", () => resolve2())));
+        exits.set(pid, new Promise((resolve) => child.once("exit", () => resolve())));
         child.unref();
         const start = startTimeOf(pid);
         if (start === null) throw new Error(`${command} exited as soon as it started; its console is at ${input.consolePath}`);
@@ -897,8 +792,8 @@ function createFirecrackerHost(options = {}) {
       }
       const exited = exits.get(vm.pid);
       const deadline = Date.now() + STOP_WAIT_MS;
-      if (exited !== void 0) await Promise.race([exited, new Promise((resolve2) => setTimeout(resolve2, STOP_WAIT_MS))]);
-      while (alive(vm) && Date.now() < deadline) await new Promise((resolve2) => setTimeout(resolve2, POLL_MS));
+      if (exited !== void 0) await Promise.race([exited, new Promise((resolve) => setTimeout(resolve, STOP_WAIT_MS))]);
+      while (alive(vm) && Date.now() < deadline) await new Promise((resolve) => setTimeout(resolve, POLL_MS));
       exits.delete(vm.pid);
     },
     alive
@@ -908,7 +803,7 @@ function createFirecrackerHost(options = {}) {
 // src/runner/microvm/host.ts
 function createMicroVmPorts(over = {}) {
   return {
-    assets: over.assets ?? ((runnerDir2) => ensureAssets({ runnerDir: runnerDir2 })),
+    assets: over.assets ?? ((runnerDir) => ensureAssets({ runnerDir })),
     rootfs: over.rootfs ?? createRootfsHost(),
     firecracker: over.firecracker ?? createFirecrackerHost(),
     cgroup: over.cgroup ?? realCgroupPort(),
@@ -921,6 +816,10 @@ var aborted = () => ({ ok: false, reason: "", aborted: true });
 function firstLine3(text) {
   return text.trim().split("\n")[0] ?? "";
 }
+function gitErrorLine(text) {
+  const lines = text.split("\n").map((line) => line.trim()).filter((line) => line !== "");
+  return lines.find((line) => /^(fatal|error):/.test(line)) ?? lines.at(-1) ?? "";
+}
 function adoptionFailureReason(result) {
   const line = result.stdout.trim().split("\n").at(-1) ?? "";
   try {
@@ -935,7 +834,10 @@ async function runBuildSteps(input) {
   const rewrite = await exec(["git", "config", "--global", `url.http://127.0.0.1:${RELAY_PORT}/github.com/.insteadOf`, "https://github.com/"], "/build/work");
   if (rewrite.status !== 0) return { ok: false, reason: `configuring the build's git remote failed (exit ${rewrite.status})` };
   const clone = await exec(["git", "clone", "--filter=blob:none", "--single-branch", `https://github.com/${repository}.git`, CHECKOUT_DIR], "/build/work");
-  if (clone.status !== 0) return { ok: false, reason: `the clone of ${repository} failed (exit ${clone.status})` };
+  if (clone.status !== 0) {
+    const detail = gitErrorLine(clone.stderr);
+    return { ok: false, reason: `the clone of ${repository} failed (exit ${clone.status})${detail === "" ? "" : `: ${detail}`}` };
+  }
   try {
     const prepared = await prepareBranch({
       workdir: CHECKOUT_DIR,
@@ -1150,9 +1052,9 @@ async function git(args, cwd, env, input) {
     if (size < maxOutputBytes) out.push(chunk);
     size += chunk.length;
   });
-  const closed = new Promise((resolve2, reject) => {
+  const closed = new Promise((resolve, reject) => {
     child.once("error", reject);
-    child.once("close", (status) => resolve2(status));
+    child.once("close", (status) => resolve(status));
   });
   if (input !== void 0) {
     await pipeline(input, child.stdin).catch(() => void 0);
@@ -1349,14 +1251,14 @@ async function drain(req) {
   }
 }
 function readPrefix(req, gzip) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve, reject) => {
     const held = [];
     const finish = (section) => {
       req.off("data", onData);
       req.off("end", onEnd);
       req.off("error", reject);
       req.pause();
-      resolve2({ held, section });
+      resolve({ held, section });
     };
     const onData = (chunk) => {
       held.push(chunk);
@@ -1370,19 +1272,19 @@ function readPrefix(req, gzip) {
   });
 }
 function readBody(req, limit) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve, reject) => {
     const chunks = [];
     let size = 0;
     req.on("data", (chunk) => {
       size += chunk.length;
       if (size > limit) {
         req.pause();
-        resolve2(void 0);
+        resolve(void 0);
         return;
       }
       chunks.push(chunk);
     });
-    req.once("end", () => resolve2(Buffer.concat(chunks)));
+    req.once("end", () => resolve(Buffer.concat(chunks)));
     req.once("error", reject);
   });
 }
@@ -1395,7 +1297,7 @@ function createGitRemote(options) {
     const { route, res } = input;
     const url = new URL(`${gitUrl}/${route.owner}/${route.name}.git/${route.kind === "info-refs" ? "info/refs" : route.kind === "lfs-batch" ? "info/lfs/objects/batch" : `git-${route.kind}`}${route.search === "" ? "" : `?${route.search}`}`);
     const send = url.protocol === "https:" ? request$1 : request;
-    return new Promise((resolve2) => {
+    return new Promise((resolve) => {
       const upstream = send(url, { method: input.method, headers: { ...input.headers, connection: "close" } }, (answer) => {
         const headers = {};
         for (const [name, value] of Object.entries(answer.headers)) {
@@ -1417,18 +1319,18 @@ function createGitRemote(options) {
         });
         answer.once("end", () => {
           res.end();
-          resolve2();
+          resolve();
         });
         answer.once("error", () => {
           res.destroy();
-          resolve2();
+          resolve();
         });
       });
       upstream.on("error", (err) => {
         log(`could not reach GitHub for ${route.kind}: ${err.message}`);
         if (res.headersSent) res.destroy();
         else plain(res, 502, "the runner could not reach GitHub\n");
-        resolve2();
+        resolve();
       });
       res.once("close", () => upstream.destroy());
       input.feed(upstream);
@@ -1537,6 +1439,11 @@ function createGitRemote(options) {
       req.resume();
       return plain(res, 404, "not found\n");
     }
+    if (options.readOnly === true && (route.kind === "receive-pack" || route.kind === "info-refs" && route.service === "git-receive-pack")) {
+      log(`push refused: this remote is read-only`);
+      req.resume();
+      return plain(res, 403, "this remote is read-only: a check cannot push\n");
+    }
     const own = isOwnRepository(options.repository, route.owner, route.name);
     if (own && route.kind === "receive-pack") return push(req, res, route);
     let kind = route.kind === "info-refs" && route.service === "git-receive-pack" ? "push" : "read";
@@ -1545,6 +1452,7 @@ function createGitRemote(options) {
       body = await readBody(req, maxLfsBodyBytes);
       if (body === void 0) return plain(res, 413, "the request is too large\n");
       kind = isLfsUpload(body) ? "push" : "read";
+      if (options.readOnly === true && kind === "push") return plain(res, 403, "this remote is read-only: a check cannot upload\n");
     }
     let authorization;
     if (own) {
@@ -1717,7 +1625,7 @@ async function startTunnel(socketPath, opts = {}) {
   if (Buffer.byteLength(socketPath) > MAX_SOCKET_PATH_BYTES) {
     throw new Error(`${socketPath} is too long for a Unix socket; keep the runner's config file nearer the root of the filesystem`);
   }
-  const resolve2 = opts.resolve ?? systemResolve;
+  const resolve = opts.resolve ?? systemResolve;
   const openConnection = opts.connect ?? ((t) => connect({ host: t.address, port: t.port }));
   const ownAddresses = opts.hostAddresses ?? systemHostAddresses;
   const connectTimeoutMs = opts.connectTimeoutMs ?? CONNECT_TIMEOUT_MS;
@@ -1801,7 +1709,7 @@ async function startTunnel(socketPath, opts = {}) {
     }
     let addresses;
     try {
-      addresses = await resolve2(host);
+      addresses = await resolve(host);
     } catch {
       return { ok: false, status: 502, body: `could not resolve ${host}
 ` };
@@ -1980,13 +1888,14 @@ function createContainerRuntime(opts = {}) {
         configPath: build.configPath,
         cli: cli ?? currentCliBuild(),
         readToken: build.readToken,
-        guestHelper: build.guestHelper
+        guestHelper: build.guestHelper,
+        log: build.log
       },
-      { host: opts.imageHost ?? createDockerHost() }
+      { host: opts.imageHost ?? createDockerHost({ builder: builderSpec(build.configPath, build.buildMemory, opts.hostEnv ?? process.env) }) }
     )),
     startTunnel: opts.startTunnel ?? startTunnel,
     tunnelOptions: opts.tunnelOptions,
-    sleep: opts.sleep ?? ((ms) => new Promise((resolve2) => setTimeout(resolve2, ms))),
+    sleep: opts.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms))),
     hostEnv: opts.hostEnv ?? process.env,
     credentials: opts.credentials ?? /* @__PURE__ */ new Map(),
     github: { gitUrl: opts.github?.gitUrl ?? "https://github.com", apiUrl: opts.github?.apiUrl ?? "https://api.github.com" },
@@ -2021,7 +1930,8 @@ function gitRemoteFor(runtime, input) {
     onWorkflowRefused: () => {
       input.tokens.reason = WORKFLOW_PERMISSION_REASON;
     },
-    log: input.log
+    log: input.log,
+    ...input.readOnly === true ? { readOnly: true } : {}
   });
 }
 function firstLine4(text) {
@@ -2056,7 +1966,17 @@ async function obtainImage(input) {
       };
     }
     try {
-      return { ok: true, built: await runtime.buildImage({ repository, configPath: config.configPath, readToken, guestHelper: input.guestHelper }) };
+      return {
+        ok: true,
+        built: await runtime.buildImage({
+          repository,
+          configPath: config.configPath,
+          buildMemory: config.build?.memory ?? "8g",
+          readToken,
+          guestHelper: input.guestHelper,
+          log: (line) => log.line(`${tag} ${line}`)
+        })
+      };
     } catch (err) {
       if (err instanceof RecipeError && err.code === "build_in_progress" && (input.now?.() ?? /* @__PURE__ */ new Date()).getTime() < input.deadlineMs) {
         log.line(`${tag} waiting for another build of ${repository}'s image`);
@@ -2065,7 +1985,8 @@ async function obtainImage(input) {
       }
       if (err instanceof RecipeError) {
         log.error(`${tag} image build for ${repository} failed: ${err.code}: ${err.message}`);
-        return { ok: false, reason: err.code };
+        const says = err.code === "image_build_out_of_memory" || err.code === "image_builder_unavailable";
+        return { ok: false, reason: says ? err.message : err.code };
       }
       return { ok: false, reason: `the image build failed: ${describeCallFailure(err)}` };
     }
@@ -2105,7 +2026,8 @@ async function provisionContainer(input) {
     repository,
     imageId: report.imageId,
     containerEnv: report.apply.containerEnv,
-    builtIns: true
+    builtIns: true,
+    lifecycle: report.apply.lifecycle
   };
   const env = buildEnvironment({
     config,
@@ -2171,7 +2093,9 @@ async function provisionContainer(input) {
     image: report.imageId,
     user: ADDED_USER,
     limits: limits2,
-    destinations: config.build?.destinations?.length ?? 0};
+    destinations: config.build?.destinations?.length ?? 0,
+    builtIns: true
+  };
   const prepared = await host.run(prepareRunArgs(runInput), { logPath });
   if (prepared.status !== 0) return dockerFailed("preparing the build's volume", prepared);
   const started = await host.run(containerRunArgs(runInput), { logPath });
@@ -2388,5 +2312,75 @@ async function cleanupContainer(runtime, state, jobDir) {
   rmSync(state.buildDir, { recursive: true, force: true });
   if (failures.length > 0) throw new Error(failures.join("; "));
 }
+async function startCheckContainer(input) {
+  const { config, runtime, job, jobDir, tokens, log } = input;
+  const { host } = runtime;
+  const tag = `#${job.item}`;
+  const built = job.container;
+  const repository = built?.repository ?? job.repository;
+  if (built === void 0 || built.imageId === void 0 || repository === void 0 || job.branch === void 0) {
+    return { ok: false, reason: "the build's image, repository or branch is not recorded" };
+  }
+  const buildId = randomBytes(6).toString("hex");
+  const name = `outerlayer-check-${buildId}`;
+  const buildDir2 = buildDir(config.configPath, buildId);
+  const agentUser = built.agentUser ?? ADDED_USER;
+  const state = { buildId, container: name, volume: name, buildDir: buildDir2, repository, imageId: built.imageId, agentUser };
+  const checksDir = join(jobDir, "checks");
+  mkdirSync(checksDir, { recursive: true });
+  const logPath = join(checksDir, "environment.log");
+  input.save(state);
+  const fail = async (reason) => {
+    try {
+      await cleanupContainer(runtime, state);
+    } catch (err) {
+      log.error(`${tag} cleanup of the check environment failed: ${describeCallFailure(err)}`);
+    }
+    return { ok: false, reason };
+  };
+  const dockerFailed = (what, result) => fail(`${what} failed (exit ${result.status})${firstLine4(result.stderr) === "" ? "" : `: ${firstLine4(result.stderr)}`}`);
+  mkdirSync(buildDir2, { recursive: true });
+  chmodSync(buildDir2, 493);
+  try {
+    const gitRemote = gitRemoteFor(runtime, { repository, branch: job.branch, tokens, buildDir: buildDir2, log: (line) => log.line(`${tag} ${line}`), readOnly: true });
+    runtime.tunnels.set(buildId, await startServicesFor(runtime, config, buildDir2, checksDir, void 0, false, gitRemote));
+  } catch (err) {
+    return fail(`the tunnel could not start: ${describeCallFailure(err)}`);
+  }
+  const limits2 = { memory: config.build?.memory ?? "8g", cpus: config.build?.cpus ?? 4, pids: config.build?.pids ?? 4096 };
+  const runnerId = runnerLabelValue(config.configPath);
+  const volume = await host.createVolume(name, { [BUILD_LABEL]: buildId, [RUNNER_LABEL]: runnerId });
+  if (volume.status !== 0) return dockerFailed("creating the check environment's volume", volume);
+  const runInput = {
+    buildId,
+    runnerId,
+    container: name,
+    volume: name,
+    buildDir: buildDir2,
+    image: built.imageId,
+    user: ADDED_USER,
+    limits: limits2,
+    destinations: config.build?.destinations?.length ?? 0,
+    builtIns: false
+  };
+  const prepared = await host.run(prepareRunArgs(runInput), { logPath });
+  if (prepared.status !== 0) return dockerFailed("preparing the check environment's volume", prepared);
+  const started = await host.run(containerRunArgs(runInput), { logPath });
+  if (started.status !== 0) return dockerFailed("starting the check environment's container", started);
+  if (!await waitForRelay(runtime, state)) return fail("the relay in the check environment's container did not start");
+  const env = checkEnvironment({ config, item: job.item, repository, hostEnv: runtime.hostEnv, containerEnv: built.containerEnv ?? {} });
+  return {
+    ok: true,
+    container: {
+      state,
+      exec: (argv, workdir, opts) => host.exec({ container: name, user: agentUser, workdir, env, argv }, opts?.logPath === void 0 ? void 0 : { logPath: opts.logPath }),
+      restart: async () => {
+        await host.stop(name);
+        const again = await host.start(name);
+        return again.status === 0 && await waitForRelay(runtime, state);
+      }
+    }
+  };
+}
 
-export { ADDED_USER, AgentUserError, AssetError, BUILD_LABEL, BuildTokens, GH_CONFIG_YML, MIN_ENGINE_MAJOR, RUNNER_LABEL, classifyRefusal, cleanupContainer, containerCommandLine, containerSenderCommand, createBuildDisk, createContainerRuntime, createRunnerLog, deleteBuildDisk, describeCallFailure, ensureRootfs, ensureTunnel, formatClock, formatDuration, ghHostsYml, gitRemoteFor, isLiteralAddress, keepGhConfigCurrent, lifecycleFailureReason, lifecycleSteps, machineConfig, measureDisk, obtainImage, prepareBranch, provisionContainer, refusalCode, relativeToRunner, removeStagedContext, resolveAgentUser, retrySend, runBuildSteps, runnerLabelValue, senderSignalScript, setUpRunnerCgroup, shellQuote, shortClaim, signalInContainer, stageGovernedContext, startServicesFor, stopContainer, syncInContainer };
+export { ADDED_USER, AgentUserError, AssetError, BuildTokens, GH_CONFIG_YML, MIN_ENGINE_MAJOR, classifyRefusal, cleanupContainer, containerCommandLine, containerSenderCommand, createBuildDisk, createContainerRuntime, createRunnerLog, deleteBuildDisk, describeCallFailure, ensureRootfs, ensureTunnel, formatClock, formatDuration, ghHostsYml, gitRemoteFor, isLiteralAddress, keepGhConfigCurrent, lifecycleFailureReason, lifecycleSteps, machineConfig, measureDisk, obtainImage, outOfMemoryReason, prepareBranch, provisionContainer, refusalCode, relativeToRunner, removeStagedContext, resolveAgentUser, retrySend, runBuildSteps, senderSignalScript, setUpRunnerCgroup, shellQuote, shortClaim, signalInContainer, stageGovernedContext, startCheckContainer, startServicesFor, stopContainer, syncInContainer };

package/dist/chunk-CX22S5BA.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+
+createRequire(import.meta.url);
+
+// src/runner/image/pins.ts
+var CLAUDE_CODE_VERSION = "2.1.284";
+var DEFAULT_BASE_IMAGE = "ubuntu:24.04@sha256:008173c23f95b170204355c12626cb5a965d779a7e1283b09e9cffbb1bf33ca3";
+var NODE_IMAGE = "node:22-bookworm-slim@sha256:43ac6c60b8f89723f746e8a92ce91abd5017e627ce1ddfe4238355d3a30b772c";
+var BUILDKIT_IMAGE = "moby/buildkit:v0.33.1@sha256:cec9f139f45e93c5c69c60f8b07cfad9f43f4ef6b6a6cd917527fea5ff2e3dea";
+var GH_VERSION = "2.101.0";
+var GH_SHA256 = {
+  amd64: "9bca2d1c16825f109907a23307628a2f0698fbf99662b73a5cf0b020293072b8",
+  arm64: "b57e8063f18862647c9d22727c32e9da1b963f8bf9db648fe123a6975695640f"
+};
+var TINI_VERSION = "0.19.0";
+var TINI_SHA256 = {
+  amd64: "c5b0666b4cb676901f90dfcb37106783c5fe2077b04590973b885950611b30ee",
+  arm64: "eae1d3aa50c48fb23b8cbdf4e369d0910dfc538566bfd09df89a774aa84a48b9"
+};
+var MICROVM_ARCHES = ["x86_64"];
+function firecrackerArch(nodeArch) {
+  return nodeArch === "x64" ? "x86_64" : nodeArch === "arm64" ? "aarch64" : nodeArch;
+}
+var FIRECRACKER_VERSION = "1.13.1";
+var FIRECRACKER_SHA256 = {
+  x86_64: "59450b9171ff2ebdf2f9a25be3a248a7ba79fb6371aec51a9d6d8eefca7b4faf"
+};
+var FIRECRACKER_BINARY_SHA256 = {
+  x86_64: "7d3924e0c8761edafbf85cb2a94c268ffad249644a40fd02d4e15cde4c206f6e"
+};
+var GUEST_ASSETS_VERSION = "1";
+var GUEST_ASSETS_BASE_URL = `https://github.com/outerlayerai/guest-assets/releases/download/guest-${GUEST_ASSETS_VERSION}`;
+var GUEST_KERNEL_SHA256 = {
+  x86_64: "5a2d716d301615c69fefc2f9574954e838269f14d5e8b0d1bad88b680cd372ee"
+};
+var GUEST_HELPER_SHA256 = {
+  x86_64: "4175e89ae8cb633113b5f69ef8b6e206093954411fe53edf86357bc1b7e822f9"
+};
+function guestAssetsPinned(arch) {
+  const zero = "0".repeat(64);
+  return GUEST_KERNEL_SHA256[arch] !== zero && GUEST_HELPER_SHA256[arch] !== zero;
+}
+
+export { BUILDKIT_IMAGE, CLAUDE_CODE_VERSION, DEFAULT_BASE_IMAGE, FIRECRACKER_BINARY_SHA256, FIRECRACKER_SHA256, FIRECRACKER_VERSION, GH_SHA256, GH_VERSION, GUEST_ASSETS_BASE_URL, GUEST_ASSETS_VERSION, GUEST_HELPER_SHA256, GUEST_KERNEL_SHA256, MICROVM_ARCHES, NODE_IMAGE, TINI_SHA256, TINI_VERSION, firecrackerArch, guestAssetsPinned };

package/dist/{chunk-H5NCNVDA.js → chunk-EV3M3EH7.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { maintainedFilesForExistingSkills, loadMaintainedFiles, writeMaintainedFiles } from './chunk-WO2BXCTQ.js';
-import { emitTree, parseOuterlayerConfig, classifyTree, generatedHeaderSource, CONTEXT_PIN_FILENAME, normalizePath } from './chunk-EMY4I27X.js';
+import { maintainedFilesForExistingSkills, loadMaintainedFiles, writeMaintainedFiles } from './chunk-VXLJORHL.js';
+import { emitTree, parseOuterlayerConfig, classifyTree, generatedHeaderSource, CONTEXT_PIN_FILENAME, normalizePath } from './chunk-7ZR5UPMB.js';
 import { existsSync, readFileSync, mkdirSync, writeFileSync, copyFileSync, readdirSync } from 'fs';
 import { join, dirname, relative, sep } from 'path';