@outerlayer/cli 0.2.0 → 0.4.0

package/dist/chunk-ZM2IMMYN.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { join, dirname } from 'path';
+
+createRequire(import.meta.url);
+var RUNNER_DIR_MODE = 448;
+var RUNNER_FILE_MODE = 384;
+function runnerDir(configPath) {
+  return join(dirname(configPath), "runner");
+}
+function hostKeyPath(configPath) {
+  return join(runnerDir(configPath), "host-key.pem");
+}
+function pidFilePath(configPath) {
+  return join(runnerDir(configPath), "runner.pid");
+}
+function jobsDir(configPath) {
+  return join(runnerDir(configPath), "jobs");
+}
+function jobDir(configPath, queue, item, claimId, attempt) {
+  const suffix = attempt === void 0 ? "" : `-${attempt}`;
+  return join(jobsDir(configPath), `${queue}-${item}-${claimId}${suffix}`);
+}
+function attemptStamp(at) {
+  return at.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+}
+function imagesDir(configPath) {
+  return join(runnerDir(configPath), "images");
+}
+function repoCacheDir(configPath, owner, name) {
+  return join(runnerDir(configPath), "repos", owner, name);
+}
+function buildsDir(configPath) {
+  return join(runnerDir(configPath), "builds");
+}
+function buildDir(configPath, buildId) {
+  return join(buildsDir(configPath), buildId);
+}
+function ghConfigDir(buildDirPath) {
+  return join(buildDirPath, "gh");
+}
+function mirrorDir(runnerDirPath, owner, name) {
+  return join(runnerDirPath, "mirrors", owner, `${name}.git`);
+}
+function spoolDir(runnerDirPath) {
+  return join(runnerDirPath, "spool");
+}
+function contextHomeDir(configPath) {
+  return join(runnerDir(configPath), "context-home");
+}
+function stagedContextDir(buildDirPath) {
+  return join(buildDirPath, "context");
+}
+function runnerDirOfBuild(buildDirPath) {
+  return dirname(dirname(buildDirPath));
+}
+function vmDir(runnerDirPath) {
+  return join(runnerDirPath, "vm");
+}
+function vmAssetsDir(runnerDirPath) {
+  return join(vmDir(runnerDirPath), "assets");
+}
+function rootfsDir(runnerDirPath) {
+  return join(vmDir(runnerDirPath), "rootfs");
+}
+function rootfsPathFor(runnerDirPath, imageId) {
+  return join(rootfsDir(runnerDirPath), `${imageId.replace(/^sha256:/, "").replace(/[^A-Za-z0-9._-]/g, "_")}.ext4`);
+}
+function diskTemplatesDir(runnerDirPath) {
+  return join(vmDir(runnerDirPath), "templates");
+}
+function vsockPath(buildDirPath) {
+  return join(buildDirPath, "v.sock");
+}
+
+export { RUNNER_DIR_MODE, RUNNER_FILE_MODE, attemptStamp, buildDir, contextHomeDir, diskTemplatesDir, ghConfigDir, hostKeyPath, imagesDir, jobDir, jobsDir, mirrorDir, pidFilePath, repoCacheDir, rootfsDir, rootfsPathFor, runnerDir, runnerDirOfBuild, spoolDir, stagedContextDir, vmAssetsDir, vsockPath };

package/dist/chunk-ZMYPLFG3.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { C } from './chunk-YRYMNBGQ.js';
+import { resolvePackRoot, loadTemplateFiles, loadMaintainedFiles, TEMPLATE_SKILLS, skillDir, writeMaintainedFiles, MAINTAINED_SKILLS } from './chunk-WO2BXCTQ.js';
+import { resolvePackageVersion } from './chunk-RA3O54FC.js';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join, dirname } from 'path';
+
+createRequire(import.meta.url);
+var DEFAULT_TEMPLATE = "default";
+var POLICY_PATH = ".outerlayer/policy.yaml";
+var POLICY_CONTENT = "extends: outerlayer:recommended@v1\nreview: required\n";
+var StarterPackError = class extends Error {
+};
+function assertKnownTemplate(name) {
+  if (name !== DEFAULT_TEMPLATE) {
+    throw new StarterPackError(`unknown template "${name}" \u2014 the only template is "${DEFAULT_TEMPLATE}"`);
+  }
+}
+function installStarterPack(opts) {
+  const packRoot = opts.packRoot ?? resolvePackRoot();
+  const version = opts.version ?? resolvePackageVersion();
+  const templateFiles = loadTemplateFiles(packRoot, version);
+  const maintainedFiles = loadMaintainedFiles(packRoot, version);
+  const copied = [];
+  const kept = [];
+  for (const skill of TEMPLATE_SKILLS) {
+    if (existsSync(join(opts.repoRoot, skillDir(skill)))) {
+      kept.push(skill);
+      continue;
+    }
+    for (const file of templateFiles.filter((f) => f.skill === skill)) {
+      const abs = join(opts.repoRoot, file.path);
+      mkdirSync(dirname(abs), { recursive: true });
+      writeFileSync(abs, file.content);
+    }
+    copied.push(skill);
+  }
+  const written = writeMaintainedFiles(opts.repoRoot, maintainedFiles);
+  let policy = "kept";
+  const policyAbs = join(opts.repoRoot, POLICY_PATH);
+  if (!existsSync(policyAbs)) {
+    mkdirSync(dirname(policyAbs), { recursive: true });
+    writeFileSync(policyAbs, POLICY_CONTENT);
+    policy = "written";
+  }
+  return { copied, kept, maintained: [...written.created, ...written.rewritten], policy };
+}
+var skillFile = (skill) => `${skillDir(skill)}/SKILL.md`;
+function formatStarterPackOutput(result) {
+  const lines = [];
+  lines.push(`${C.green}\u2713${C.reset} Installed the starter skills in .outerlayer/skills/`, "");
+  lines.push("Yours to edit \u2014 copied once, never overwritten:");
+  for (const skill of TEMPLATE_SKILLS) {
+    lines.push(
+      result.kept.includes(skill) ? `  ${C.dim}kept${C.reset} ${skillDir(skill)}/ ${C.dim}(already exists, left exactly as it is)${C.reset}` : `  ${skillFile(skill)}`
+    );
+  }
+  lines.push("", "Rewritten on every emit \u2014 edits are overwritten by the installed CLI:");
+  for (const skill of MAINTAINED_SKILLS) lines.push(`  ${skillFile(skill)}`);
+  lines.push(
+    "",
+    result.policy === "written" ? `${C.green}\u2713${C.reset} Wrote ${POLICY_PATH} (extends the recommended checks, review required)` : `${C.dim}${POLICY_PATH} already exists \u2014 left as it is${C.reset}`,
+    "",
+    `Next: create .outerlayer/config.json naming your agent tools, for example {"targets": ["claude-code"]},`,
+    `then run ${C.yellow}outerlayer context emit${C.reset} to compile the skills into their native files.`
+  );
+  return lines.join("\n") + "\n";
+}
+
+export { StarterPackError, assertKnownTemplate, formatStarterPackOutput, installStarterPack };

package/dist/chunk-ZNA27WEV.js

@@ -0,0 +1,470 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { startTimeOf, claimPidFile, RunnerAlreadyRunningError, releasePidFile } from './chunk-N5FOE5PS.js';
+import { RecipeError, locateRecipe, readRecipe, assertBuildable, writeSanitizedRecipe, classifyProperties, SANITIZED_NAME } from './chunk-QOZKPLVJ.js';
+import { RUNNER_DIR_MODE, repoCacheDir, imagesDir, attemptStamp, runnerDir, rootfsPathFor, RUNNER_FILE_MODE } from './chunk-ZM2IMMYN.js';
+import { mkdirSync, rmSync, existsSync, mkdtempSync, cpSync, readFileSync, writeFileSync, readdirSync, lstatSync, readlinkSync } from 'fs';
+import { tmpdir } from 'os';
+import { dirname, join } from 'path';
+import { execFile } from 'child_process';
+import { createHash } from 'crypto';
+
+createRequire(import.meta.url);
+var INHERITED_REPOSITORY_VARIABLES = ["GIT_DIR", "GIT_WORK_TREE", "GIT_INDEX_FILE", "GIT_COMMON_DIR"];
+function gitEnvironment(base) {
+  const env = { ...base, GIT_TERMINAL_PROMPT: "0" };
+  for (const name of INHERITED_REPOSITORY_VARIABLES) delete env[name];
+  return env;
+}
+function tokenHeader(token) {
+  return `Authorization: Basic ${Buffer.from(`x-access-token:${token}`).toString("base64")}`;
+}
+function tokenSettings(remote, token) {
+  return { GIT_CONFIG_COUNT: "1", GIT_CONFIG_KEY_0: `http.${remote}.extraHeader`, GIT_CONFIG_VALUE_0: tokenHeader(token) };
+}
+function git(cwd, args, timeoutMs, extraEnv = {}) {
+  const env = { ...gitEnvironment(process.env), ...extraEnv };
+  return new Promise((resolve, reject) => {
+    execFile(
+      "git",
+      ["-C", cwd, "-c", "core.hooksPath=/dev/null", "-c", "protocol.ext.allow=never", ...args],
+      { env, encoding: "utf8", maxBuffer: 16 * 1024 * 1024, timeout: timeoutMs },
+      (error, stdout, stderr) => {
+        if (error && error.killed && timeoutMs !== void 0) reject(new Error(`git ${args[0]} failed: no answer within ${timeoutMs / 1e3}s`));
+        else if (error) reject(new Error(`git ${args[0]} failed: ${stderr.trim() || error.message}`));
+        else resolve(stdout.trim());
+      }
+    );
+  });
+}
+function defaultBranchOf(lsRemote) {
+  const match = lsRemote.match(/^ref: refs\/heads\/(\S+)\s+HEAD$/m);
+  return match ? match[1] : null;
+}
+async function fetchDefaultBranch(opts) {
+  const created = !existsSync(opts.dir);
+  mkdirSync(opts.dir, { recursive: true, mode: RUNNER_DIR_MODE });
+  const credential = opts.token === void 0 ? {} : tokenSettings(opts.remote, opts.token);
+  const over = (args) => git(opts.dir, args, void 0, credential);
+  try {
+    const defaultBranch = defaultBranchOf(await over(["ls-remote", "--symref", opts.remote, "HEAD"]));
+    if (defaultBranch === null) {
+      throw new RecipeError(
+        "default_branch_unknown",
+        `${opts.remote} does not say which branch is its default; the runner will not guess one`
+      );
+    }
+    await git(opts.dir, ["init", "--quiet"]);
+    await over(["fetch", "--quiet", "--depth", "1", "--no-tags", "--force", opts.remote, `refs/heads/${defaultBranch}`]);
+    const commit = await git(opts.dir, ["rev-parse", "FETCH_HEAD"]);
+    await git(opts.dir, ["checkout", "--quiet", "--detach", "--force", commit]);
+    await git(opts.dir, ["clean", "-ffdx", "--quiet"]);
+    return { dir: opts.dir, defaultBranch, commit };
+  } catch (err) {
+    if (created) rmSync(opts.dir, { recursive: true, force: true });
+    if (err instanceof RecipeError || opts.repository === void 0) throw err;
+    throw unreadable(opts.repository, opts.token !== void 0, err);
+  }
+}
+var REFUSED_BY_REMOTE = /\b(401|403|404)\b|authentication failed|repository not found|could not read username|terminal prompts disabled/i;
+function unreadable(repository, withClaimToken, err) {
+  const message = (err instanceof Error ? err.message : String(err)).replace(/^git [\w-]+ failed: /, "");
+  const reason = message.split("\n")[0];
+  if (!REFUSED_BY_REMOTE.test(message)) return new RecipeError("repository_unreadable", `cannot read ${repository}: ${reason}`);
+  const advice = withClaimToken ? "the claim's read token was used and GitHub refused it, so the App installation may not include this repository" : "`outerlayer runner image` fetches with this host's git login, so a private repository needs one on this host; a container build needs none, because it uses the claim's read token";
+  return new RecipeError("repository_unreadable", `cannot read ${repository}: ${reason}; ${advice}`);
+}
+var HEAD_TIMEOUT_MS = 3e4;
+async function readDefaultBranchHead(remote, dir) {
+  let out;
+  try {
+    out = await git(dir, ["ls-remote", "--symref", remote, "HEAD"], HEAD_TIMEOUT_MS);
+  } catch {
+    return void 0;
+  }
+  return out.match(/^([0-9a-f]{40}|[0-9a-f]{64})\tHEAD$/m)?.[1];
+}
+var CLONE_TIMEOUT_MS = 6e5;
+async function cloneRepository(remote, dest, timeoutMs = CLONE_TIMEOUT_MS) {
+  mkdirSync(dirname(dest), { recursive: true, mode: RUNNER_DIR_MODE });
+  try {
+    await git(dirname(dest), ["clone", "--quiet", "--filter=blob:none", "--single-branch", remote, dest], timeoutMs);
+    return { ok: true };
+  } catch (err) {
+    rmSync(dest, { recursive: true, force: true });
+    const detail = (err instanceof Error ? err.message : String(err)).replace(/^git clone failed: /, "").split("\n")[0];
+    return { ok: false, reason: `the clone of ${remote} failed: ${detail}` };
+  }
+}
+
+// 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 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/outerlayer/releases/download/guest-${GUEST_ASSETS_VERSION}`;
+var GUEST_KERNEL_SHA256 = {
+  x86_64: "0000000000000000000000000000000000000000000000000000000000000000"
+};
+var GUEST_HELPER_SHA256 = {
+  x86_64: "0000000000000000000000000000000000000000000000000000000000000000"
+};
+function guestAssetsPinned(arch) {
+  const zero = "0".repeat(64);
+  return GUEST_KERNEL_SHA256[arch] !== zero && GUEST_HELPER_SHA256[arch] !== zero;
+}
+
+// src/runner/image/dockerfiles.ts
+function plain(name, value, allowed) {
+  if (!allowed.test(value)) throw new Error(`${name} holds a character a Dockerfile line cannot carry safely: ${JSON.stringify(value)}`);
+  return value;
+}
+function defaultDockerfile(baseImage, nodeImage) {
+  return [
+    `FROM ${baseImage}`,
+    "ENV DEBIAN_FRONTEND=noninteractive",
+    "RUN apt-get update \\",
+    " && apt-get install -y --no-install-recommends git ca-certificates curl \\",
+    " && rm -rf /var/lib/apt/lists/*",
+    `COPY --from=${nodeImage} /usr/local/bin/node /usr/local/bin/node`,
+    `COPY --from=${nodeImage} /usr/local/lib/node_modules /usr/local/lib/node_modules`,
+    "RUN ln -s ../lib/node_modules/npm/bin/npm-cli.js /usr/local/bin/npm \\",
+    " && ln -s ../lib/node_modules/npm/bin/npx-cli.js /usr/local/bin/npx \\",
+    " && ln -s ../lib/node_modules/corepack/dist/corepack.js /usr/local/bin/corepack",
+    ""
+  ].join("\n");
+}
+function toolsDockerfile(parts) {
+  const recipeImage = plain("the recipe image", parts.recipeImage, /^[A-Za-z0-9_.:@/-]+$/);
+  const nodeImage = plain("the Node image", parts.nodeImage, /^[A-Za-z0-9_.:@/-]+$/);
+  const version = plain("the Claude Code version", parts.claudeCodeVersion, /^[A-Za-z0-9.+-]+$/);
+  const buildId = plain("the build id", parts.buildId, /^[A-Za-z0-9_.:+-]+$/);
+  const tools = JSON.stringify({ outerlayerBuildId: buildId, claudeCodeVersion: version, ghVersion: GH_VERSION });
+  const managedSettings = JSON.stringify({
+    hooks: Object.fromEntries(
+      ["SessionStart", "SessionEnd", "Stop", "PostToolUse"].map((event) => [event, [{ hooks: [{ type: "command", command: `outerlayer hook ${event}` }] }]])
+    )
+  });
+  const download = `node -e 'fetch(process.argv[1]).then((r)=>{if(!r.ok)throw new Error(process.argv[1]+" "+r.status);return r.arrayBuffer()}).then((b)=>require("fs").writeFileSync(process.argv[2],Buffer.from(b)))'`;
+  return [
+    `FROM ${recipeImage} AS recipe`,
+    `FROM ${nodeImage} AS stage`,
+    "ARG TARGETARCH",
+    `RUN npm install --global --prefix /out/opt/outerlayer/claude @anthropic-ai/claude-code@${version}`,
+    "COPY dist /out/opt/outerlayer/cli/dist",
+    "COPY package.json /out/opt/outerlayer/cli/package.json",
+    "RUN mkdir -p /out/opt/outerlayer/bin /out/usr/local/bin /out/etc/claude-code /out/build \\",
+    " && cp /usr/local/bin/node /out/opt/outerlayer/bin/node \\",
+    ` && printf '%s\\n' '#!/bin/sh' 'exec /opt/outerlayer/bin/node /opt/outerlayer/cli/dist/index.js "$@"' > /out/usr/local/bin/outerlayer \\`,
+    ` && printf '%s\\n' '#!/bin/sh' 'PATH=/opt/outerlayer/bin:$PATH' 'export PATH' 'exec /opt/outerlayer/claude/bin/claude "$@"' > /out/usr/local/bin/claude \\`,
+    ` && printf '%s\\n' '${tools}' > /out/opt/outerlayer/tools.json \\`,
+    ` && printf '%s\\n' '${managedSettings}' > /out/etc/claude-code/managed-settings.json \\`,
+    " && chmod 0755 /out/usr/local/bin/outerlayer /out/usr/local/bin/claude \\",
+    // Every build, whatever user runs it, writes here: the first mount of an empty volume copies this mode.
+    " && chmod 1777 /out/build",
+    ...parts.guestHelper === true ? [
+      "COPY guest/outerlayer-guest /out/opt/outerlayer/bin/outerlayer-guest",
+      // The guest mounts the build's tmpfs, the kernel's file systems and the run directory over these.
+      "RUN chmod 0755 /out/opt/outerlayer/bin/outerlayer-guest \\",
+      " && mkdir -p /out/outerlayer/job /out/run /out/proc /out/sys /out/dev"
+    ] : [],
+    `RUN set -eu \\`,
+    ` && case "$TARGETARCH" in \\`,
+    `      amd64) gh_sha=${GH_SHA256.amd64}; tini_sha=${TINI_SHA256.amd64} ;; \\`,
+    `      arm64) gh_sha=${GH_SHA256.arm64}; tini_sha=${TINI_SHA256.arm64} ;; \\`,
+    `      *) echo "no pinned gh and tini for $TARGETARCH" >&2; exit 1 ;; \\`,
+    "    esac \\",
+    ` && ${download} https://github.com/krallin/tini/releases/download/v${TINI_VERSION}/tini-static-$TARGETARCH /tmp/tini \\`,
+    ' && echo "$tini_sha  /tmp/tini" | sha256sum -c - \\',
+    " && install -m 0755 /tmp/tini /out/opt/outerlayer/bin/tini \\",
+    ` && ${download} https://github.com/cli/cli/releases/download/v${GH_VERSION}/gh_${GH_VERSION}_linux_$TARGETARCH.tar.gz /tmp/gh.tgz \\`,
+    ' && echo "$gh_sha  /tmp/gh.tgz" | sha256sum -c - \\',
+    " && tar -xzf /tmp/gh.tgz -C /tmp \\",
+    ` && install -m 0755 /tmp/gh_${GH_VERSION}_linux_$TARGETARCH/bin/gh /out/usr/local/bin/gh`,
+    "COPY --from=recipe /etc/passwd /tmp/recipe-passwd",
+    "COPY --from=recipe /etc/group /tmp/recipe-group",
+    `RUN uid=$(awk -F: 'BEGIN{m=1499} $3>=1500 && $3<60000 && $3>m{m=$3} END{print m+1}' /tmp/recipe-passwd) \\`,
+    ` && gid=$(awk -F: 'BEGIN{m=1499} $3>=1500 && $3<60000 && $3>m{m=$3} END{print m+1}' /tmp/recipe-group) \\`,
+    " && { grep -v '^ol-agent:' /tmp/recipe-passwd > /out/etc/passwd || true; } \\",
+    " && { grep -v '^ol-agent:' /tmp/recipe-group > /out/etc/group || true; } \\",
+    ` && printf '%s\\n' "ol-agent:x:$uid:$gid::/build/home:/bin/sh" >> /out/etc/passwd \\`,
+    ` && printf '%s\\n' "ol-agent:x:$gid:" >> /out/etc/group \\`,
+    " && chmod 0644 /out/etc/passwd /out/etc/group \\",
+    " && chmod -R a+rX /out",
+    `FROM ${recipeImage}`,
+    "COPY --from=stage /out/ /",
+    "ENV DISABLE_AUTOUPDATER=1",
+    "RUN outerlayer --version && claude --version && gh --version",
+    ""
+  ].join("\n");
+}
+function sha256(...chunks) {
+  const hash = createHash("sha256");
+  for (const chunk of chunks) hash.update(chunk);
+  return hash.digest("hex");
+}
+function filesUnder(root, dir) {
+  const found = [];
+  for (const entry of readdirSync(join(root, dir))) {
+    const rel = join(dir, entry);
+    if (rel === join(".devcontainer", SANITIZED_NAME)) continue;
+    const stat = lstatSync(join(root, rel));
+    if (stat.isDirectory()) found.push(...filesUnder(root, rel));
+    else found.push(rel);
+  }
+  return found;
+}
+function hashFile(root, rel) {
+  const path = join(root, rel);
+  const bytes = lstatSync(path).isSymbolicLink() ? Buffer.from(`-> ${readlinkSync(path)}`) : readFileSync(path);
+  return [rel, "\0", bytes, "\0"];
+}
+function recipeKey(checkoutDir, location, defaultDockerfile2) {
+  if (location.kind === "default") return sha256(defaultDockerfile2);
+  const files = [];
+  if (existsSync(join(checkoutDir, ".devcontainer"))) files.push(...filesUnder(checkoutDir, ".devcontainer"));
+  if (location.path === ".devcontainer.json") {
+    files.push(".devcontainer.json");
+    if (existsSync(join(checkoutDir, ".devcontainer-lock.json"))) files.push(".devcontainer-lock.json");
+  }
+  return sha256(...files.sort().flatMap((rel) => hashFile(checkoutDir, rel)));
+}
+function toolsKey(parts) {
+  const base = [parts.buildId, "\0", parts.claudeCodeVersion, "\0", parts.nodeImage, "\0", parts.ghVersion, "\0", parts.tiniVersion];
+  return sha256(...base, ...parts.guestHelperSha256 === void 0 ? [] : ["\0guest-helper\0", parts.guestHelperSha256]);
+}
+
+// src/runner/image/prune.ts
+var KIND = "ai.outerlayer.kind";
+var RECIPE_KEY = "ai.outerlayer.recipe-key";
+var newestFirst = (a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt);
+function selectPrunable(opts) {
+  const used = new Set(opts.inUse);
+  const builds = opts.images.filter((i) => i.labels[KIND] === "build").sort(newestFirst);
+  const kept = builds.filter((image, index) => index < opts.keep || used.has(image.id));
+  const keptKeys = new Set(kept.map((i) => i.labels[RECIPE_KEY]));
+  return {
+    builds: builds.filter((i) => !kept.includes(i)),
+    recipes: opts.images.filter(
+      (i) => i.labels[KIND] === "recipe" && !used.has(i.id) && !keptKeys.has(i.labels[RECIPE_KEY])
+    )
+  };
+}
+
+// src/runner/image/build.ts
+var KIND2 = "ai.outerlayer.kind";
+var REPOSITORY = "ai.outerlayer.repository";
+var RECIPE_KEY2 = "ai.outerlayer.recipe-key";
+var TOOLS_KEY = "ai.outerlayer.tools-key";
+var KEEP_BUILD_IMAGES = 3;
+var TAG_HOST = "outerlayer.invalid";
+var KEY_PREFIX = 12;
+var LOCK_NAME = "build.lock";
+function splitRepository(repository) {
+  const full = repository.toLowerCase();
+  const parts = full.split("/");
+  const segment = /^[A-Za-z0-9_.-]+$/;
+  if (parts.length !== 2 || !parts.every((p) => segment.test(p) && p !== "." && p !== "..")) {
+    throw new RecipeError("invalid_repository", `${JSON.stringify(repository)} is not an owner/name repository`);
+  }
+  return { full, owner: parts[0], name: parts[1] };
+}
+function metadataOf(image) {
+  try {
+    const parsed = JSON.parse(image.labels["devcontainer.metadata"] ?? "[]");
+    const entries = Array.isArray(parsed) ? parsed : [parsed];
+    return entries.filter((e) => typeof e === "object" && e !== null && !Array.isArray(e));
+  } catch {
+    return [];
+  }
+}
+function readReport(recordDir) {
+  try {
+    return JSON.parse(readFileSync(join(recordDir, "recipe.json"), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeRecord(recordDir, report, builtAt) {
+  mkdirSync(recordDir, { recursive: true, mode: RUNNER_DIR_MODE });
+  const image = { imageId: report.imageId, tag: report.tag, recipeKey: report.recipeKey, toolsKey: report.toolsKey, builtAt };
+  writeFileSync(join(recordDir, "image.json"), `${JSON.stringify(image, null, 2)}
+`, { mode: RUNNER_FILE_MODE });
+  writeFileSync(join(recordDir, "recipe.json"), `${JSON.stringify(report, null, 2)}
+`, { mode: RUNNER_FILE_MODE });
+}
+async function buildRepositoryImage(opts, ports) {
+  const { host } = ports;
+  const { full: repository, owner, name } = splitRepository(opts.repository);
+  if (!existsSync(join(opts.cli.distDir, "index.js"))) {
+    throw new Error(`${opts.cli.distDir} holds no index.js: the tools layer copies the built CLI, so run this from a build (yarn workspace @outerlayer/cli build)`);
+  }
+  const now = opts.now ?? (() => /* @__PURE__ */ new Date());
+  const claudeCodeVersion = opts.claudeCodeVersion ?? CLAUDE_CODE_VERSION;
+  const nodeImage = opts.nodeImage ?? NODE_IMAGE;
+  const baseImage = opts.defaultBaseImage ?? DEFAULT_BASE_IMAGE;
+  const scratchRoot = opts.tmpDir ?? tmpdir();
+  const cacheDir = repoCacheDir(opts.configPath, owner, name);
+  const repoRecords = join(imagesDir(opts.configPath), owner, name);
+  const logPath = join(repoRecords, "builds", `${attemptStamp(now())}.log`);
+  const lockPath = join(repoRecords, LOCK_NAME);
+  const self = { pid: process.pid, start: startTimeOf(process.pid) ?? "" };
+  mkdirSync(repoRecords, { recursive: true, mode: RUNNER_DIR_MODE });
+  try {
+    claimPidFile(lockPath, self);
+  } catch (err) {
+    if (err instanceof RunnerAlreadyRunningError) {
+      throw new RecipeError("build_in_progress", `an image build for ${repository} is already running (pid ${err.pid})`);
+    }
+    throw err;
+  }
+  try {
+    const checkout = await fetchDefaultBranch({
+      remote: opts.remote ?? `https://github.com/${owner}/${name}.git`,
+      dir: cacheDir,
+      token: opts.readToken,
+      repository
+    });
+    const location = locateRecipe(checkout.dir);
+    const recipe = readRecipe(checkout.dir, location);
+    assertBuildable(checkout.dir, location, recipe);
+    const defaultText = defaultDockerfile(baseImage, nodeImage);
+    const rKey = recipeKey(checkout.dir, location, defaultText);
+    const tKey = toolsKey({ buildId: opts.cli.buildId, claudeCodeVersion, nodeImage, ghVersion: GH_VERSION, tiniVersion: TINI_VERSION, guestHelperSha256: opts.guestHelper?.sha256 });
+    const recordDir = join(repoRecords, `${rKey.slice(0, KEY_PREFIX)}-${tKey.slice(0, KEY_PREFIX)}`);
+    const buildTag = `${TAG_HOST}/build/${repository}:${rKey.slice(0, KEY_PREFIX)}-${tKey.slice(0, KEY_PREFIX)}`;
+    const recipeTag = `${TAG_HOST}/recipe/${repository}:${rKey.slice(0, KEY_PREFIX)}`;
+    const existing = await host.list(repository);
+    const labelled = existing.find((i) => i.labels[KIND2] === "recipe" && i.labels[RECIPE_KEY2] === rKey);
+    const recipeImageBefore = labelled !== void 0 && (await host.inspect(recipeTag))?.id === labelled.id ? labelled : void 0;
+    const buildImageBefore = existing.find(
+      (i) => i.labels[KIND2] === "build" && i.labels[RECIPE_KEY2] === rKey && i.labels[TOOLS_KEY] === tKey
+    );
+    const failed = (what, status) => new RecipeError("build_failed", `${what} failed (exit ${status}); the build log is at ${logPath}`, logPath);
+    let recipeImage = recipeImageBefore;
+    let recipeBuilt = false;
+    if (recipeImage === void 0 && buildImageBefore === void 0) {
+      const labels = { [REPOSITORY]: repository, [KIND2]: "recipe", [RECIPE_KEY2]: rKey };
+      if (location.kind === "default") {
+        const context = mkdtempSync(join(scratchRoot, "ol-image-default-"));
+        try {
+          const status = await host.buildDockerfile({ dockerfile: defaultText, context, tag: recipeTag, labels, logPath });
+          if (status !== 0) throw failed("the docker build of the default image", status);
+        } finally {
+          rmSync(context, { recursive: true, force: true });
+        }
+      } else {
+        const config = writeSanitizedRecipe(checkout.dir, location, recipe);
+        try {
+          const status = await host.devcontainerBuild({ workspace: checkout.dir, config, imageName: recipeTag, labels, logPath });
+          if (status !== 0) throw failed("devcontainer build", status);
+        } finally {
+          rmSync(config, { force: true });
+        }
+        const context = mkdtempSync(join(scratchRoot, "ol-image-label-"));
+        try {
+          const status = await host.buildDockerfile({ dockerfile: `FROM ${recipeTag}
+`, context, tag: recipeTag, labels, logPath });
+          if (status !== 0) throw failed("labelling the recipe image", status);
+        } finally {
+          rmSync(context, { recursive: true, force: true });
+        }
+      }
+      recipeImage = await host.inspect(recipeTag) ?? void 0;
+      if (recipeImage === void 0) throw failed("finding the recipe image after devcontainer build", 0);
+      recipeBuilt = true;
+    }
+    let buildImage = buildImageBefore;
+    if (buildImage === void 0) {
+      const context = mkdtempSync(join(scratchRoot, "ol-image-tools-"));
+      try {
+        cpSync(opts.cli.distDir, join(context, "dist"), { recursive: true });
+        cpSync(join(opts.cli.distDir, "..", "package.json"), join(context, "package.json"));
+        if (opts.guestHelper !== void 0) {
+          mkdirSync(join(context, "guest"));
+          cpSync(opts.guestHelper.path, join(context, "guest", "outerlayer-guest"));
+        }
+        const dockerfile = toolsDockerfile({ recipeImage: recipeTag, nodeImage, claudeCodeVersion, buildId: opts.cli.buildId, guestHelper: opts.guestHelper !== void 0 });
+        const labels = { [REPOSITORY]: repository, [KIND2]: "build", [RECIPE_KEY2]: rKey, [TOOLS_KEY]: tKey };
+        const status = await host.buildDockerfile({ dockerfile, context, tag: buildTag, labels, logPath });
+        if (status !== 0) throw failed("the docker build of the tools layer", status);
+      } finally {
+        rmSync(context, { recursive: true, force: true });
+      }
+      buildImage = await host.inspect(buildTag) ?? void 0;
+      if (buildImage === void 0) throw failed("finding the image after the tools build", 0);
+    }
+    const toolsBuilt = buildImage !== buildImageBefore;
+    let report = readReport(recordDir);
+    if (report === null || report.imageId !== buildImage.id || report.docker === void 0) {
+      report = {
+        repository,
+        sourceCommit: checkout.commit,
+        defaultBranch: checkout.defaultBranch,
+        recipe: location.kind === "default" ? "default" : location.path,
+        recipeKey: rKey,
+        toolsKey: tKey,
+        imageId: buildImage.id,
+        tag: buildTag,
+        // A rebuilt record reads the tools image's label, which it inherits from the recipe image.
+        ...classifyProperties(recipe, metadataOf(recipeImage ?? buildImage))
+      };
+      writeRecord(recordDir, report, now().toISOString());
+    }
+    const removed = [];
+    if (toolsBuilt) removed.push(...await prune(host, repository, repoRecords, opts.keep ?? KEEP_BUILD_IMAGES, runnerDir(opts.configPath)));
+    return {
+      reused: !recipeBuilt && !toolsBuilt,
+      recipeBuilt,
+      toolsBuilt,
+      checkedCommit: checkout.commit,
+      recordDir,
+      report,
+      removed
+    };
+  } finally {
+    releasePidFile(lockPath, self);
+  }
+}
+async function prune(host, repository, repoRecords, keep, runnerDirPath) {
+  const { builds, recipes } = selectPrunable({ images: await host.list(repository), inUse: await host.inUse(), keep });
+  const removed = [];
+  for (const image of [...builds, ...recipes]) {
+    try {
+      await host.remove(image.id);
+    } catch {
+      continue;
+    }
+    removed.push(image.id);
+    rmSync(rootfsPathFor(runnerDirPath, image.id), { force: true });
+    const recipeKeyLabel = image.labels[RECIPE_KEY2];
+    const toolsKeyLabel = image.labels[TOOLS_KEY];
+    if (image.labels[KIND2] === "build" && recipeKeyLabel !== void 0 && toolsKeyLabel !== void 0) {
+      rmSync(join(repoRecords, `${recipeKeyLabel.slice(0, KEY_PREFIX)}-${toolsKeyLabel.slice(0, KEY_PREFIX)}`), { recursive: true, force: true });
+    }
+  }
+  return removed;
+}
+
+export { CLAUDE_CODE_VERSION, DEFAULT_BASE_IMAGE, FIRECRACKER_BINARY_SHA256, FIRECRACKER_SHA256, FIRECRACKER_VERSION, GUEST_ASSETS_BASE_URL, GUEST_ASSETS_VERSION, GUEST_HELPER_SHA256, GUEST_KERNEL_SHA256, MICROVM_ARCHES, buildRepositoryImage, cloneRepository, firecrackerArch, guestAssetsPinned, readDefaultBranchHead };