@outerlayer/cli 0.2.0 → 0.4.0

package/dist/chunk-AUFG23AA.js

@@ -0,0 +1,534 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { existsSync, unlinkSync, chmodSync } from 'fs';
+import { request as request$1, createServer } from 'http';
+import { request } from 'https';
+import { createServer as createServer$1 } from 'net';
+import { join } from 'path';
+
+createRequire(import.meta.url);
+
+// src/runner/builtin-destinations.ts
+var GATEWAY_DESTINATION = "gateway";
+var CLAUDE_DESTINATION = "claude";
+var BUILT_IN_NAMES = [GATEWAY_DESTINATION, CLAUDE_DESTINATION];
+var GATEWAY_PORT = 3126;
+var CLAUDE_PORT = 3127;
+var GATEWAY_SOCKET = "gateway.sock";
+var CLAUDE_SOCKET = "claude.sock";
+var CLAUDE_UPSTREAM = "https://api.anthropic.com/";
+var AGENT_CREDENTIAL_MISSING = "agent_credential_missing";
+var OAUTH_PLACEHOLDER = "sk-ant-oat01-placeholder-not-a-real-token";
+var API_KEY_PLACEHOLDER = "sk-ant-api03-placeholder-not-a-real-key";
+var ITEM_KEY_PLACEHOLDER = "olitem_placeholder-not-a-real-key";
+var ITEM_KEY_VARIABLE = "OUTERLAYER_ITEM_KEY";
+var CLAUDE_CREDENTIAL_VARIABLES = ["CLAUDE_CODE_OAUTH_TOKEN", "ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN"];
+function claudeCredential(hostEnv) {
+  const held = (name) => hostEnv[name] !== void 0 && hostEnv[name] !== "";
+  if (held("CLAUDE_CODE_OAUTH_TOKEN")) return { variable: "CLAUDE_CODE_OAUTH_TOKEN", placeholder: OAUTH_PLACEHOLDER };
+  if (held("ANTHROPIC_API_KEY")) return { variable: "ANTHROPIC_API_KEY", placeholder: API_KEY_PLACEHOLDER };
+  return void 0;
+}
+function gatewayUpstream(gatewayUrl) {
+  return `${new URL(gatewayUrl).origin}/`;
+}
+function builtInDestinations(input) {
+  const credential = claudeCredential(input.hostEnv);
+  const apiKeyMode = credential?.variable === "ANTHROPIC_API_KEY";
+  return [
+    {
+      destination: {
+        name: GATEWAY_DESTINATION,
+        upstream: gatewayUpstream(input.gatewayUrl),
+        header: { name: "Authorization", value: `Bearer \${${ITEM_KEY_VARIABLE}}`, variables: [ITEM_KEY_VARIABLE] },
+        env: {}
+      },
+      hostEnv: input.itemKey === void 0 ? {} : { [ITEM_KEY_VARIABLE]: input.itemKey },
+      drop: [],
+      socket: GATEWAY_SOCKET
+    },
+    {
+      destination: {
+        name: CLAUDE_DESTINATION,
+        upstream: input.claudeUpstream ?? CLAUDE_UPSTREAM,
+        header: apiKeyMode ? { name: "x-api-key", value: "${ANTHROPIC_API_KEY}", variables: ["ANTHROPIC_API_KEY"] } : { name: "Authorization", value: "Bearer ${CLAUDE_CODE_OAUTH_TOKEN}", variables: ["CLAUDE_CODE_OAUTH_TOKEN"] },
+        env: {}
+      },
+      hostEnv: input.hostEnv,
+      // A build's own key in either header would sit beside the runner's, and the upstream takes one of them.
+      drop: ["x-api-key", "authorization"],
+      socket: CLAUDE_SOCKET
+    }
+  ];
+}
+function builtInEnvironment(localFor, credential) {
+  return {
+    OUTERLAYER_URL: localFor(GATEWAY_DESTINATION),
+    OUTERLAYER_API_KEY: ITEM_KEY_PLACEHOLDER,
+    ANTHROPIC_BASE_URL: localFor(CLAUDE_DESTINATION),
+    ...credential === void 0 ? {} : { [credential.variable]: credential.placeholder },
+    CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1"
+  };
+}
+
+// src/runner/destinations.ts
+var MAX_RELEASED_DESTINATIONS = 20;
+var MAX_DESTINATIONS = MAX_RELEASED_DESTINATIONS - BUILT_IN_NAMES.length;
+var DESTINATION_BASE_PORT = 3129;
+var DESTINATION_NAME = /^[a-z0-9][a-z0-9-]{0,62}$/;
+var VARIABLE_NAME = /^[A-Za-z_][A-Za-z0-9_]{0,254}$/;
+var HEADER_NAME = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+var HEADER_VARIABLE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
+var DESTINATION_KEYS = ["name", "upstream", "header", "env"];
+var MAX_SOCKET_PATH_BYTES = 100;
+var UPSTREAM_IDLE_MS = 6e5;
+function headerVariables(destinations) {
+  return [...new Set((destinations ?? []).flatMap((d) => d.header.variables))];
+}
+function resolveDestinations(given, variables, isReserved, fail) {
+  if (!Array.isArray(given)) fail("runner.build.destinations", "must be a list of destinations");
+  if (given.length > MAX_DESTINATIONS) {
+    fail(
+      "runner.build.destinations",
+      `lists ${given.length} destinations; a release records at most ${MAX_RELEASED_DESTINATIONS}, and ${BUILT_IN_NAMES.length} of those are the built-in ${BUILT_IN_NAMES.join(" and ")} destinations, so a host lists at most ${MAX_DESTINATIONS}`
+    );
+  }
+  const resolved = [];
+  const names = /* @__PURE__ */ new Set();
+  const envNames = /* @__PURE__ */ new Set();
+  for (const [index, entry] of given.entries()) {
+    const at = `runner.build.destinations[${index}]`;
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) fail(at, "must be an object");
+    const record = entry;
+    for (const key of Object.keys(record)) {
+      if (!DESTINATION_KEYS.includes(key)) {
+        fail(`${at}.${key}`, `is not a key a destination accepts; the keys are ${DESTINATION_KEYS.join(", ")}`);
+      }
+    }
+    const name = record.name;
+    if (typeof name !== "string" || !DESTINATION_NAME.test(name)) {
+      fail(`${at}.name`, "must be 1 to 63 lower-case letters, digits or hyphens, starting with a letter or digit");
+    }
+    if (BUILT_IN_NAMES.includes(name)) fail(`${at}.name`, `is ${name}, a destination the runner serves itself`);
+    if (names.has(name)) fail(`${at}.name`, `repeats the destination ${name}`);
+    names.add(name);
+    const upstream = parseUpstream(record.upstream, `${at}.upstream`, fail);
+    const header = parseHeader(record.header, `${at}.header`, fail);
+    for (const variable of header.variables) {
+      if (variables.includes(variable)) {
+        fail(`${at}.header`, `names ${variable}, which build.variables also passes into the build; a secret a build can read is not a destination's`);
+      }
+    }
+    const env = parseEnv(record.env, `${at}.env`, isReserved, fail);
+    for (const variable of Object.keys(env)) {
+      if (envNames.has(variable)) fail(`${at}.env`, `sets ${variable}, which another destination sets too`);
+      envNames.add(variable);
+      if (variables.includes(variable)) fail(`${at}.env`, `sets ${variable}, which build.variables also passes into the build`);
+    }
+    resolved.push({ name, upstream, header, env });
+  }
+  for (const [index, destination] of resolved.entries()) {
+    for (const variable of destination.header.variables) {
+      if (envNames.has(variable)) {
+        fail(`runner.build.destinations[${index}].env`, `sets ${variable}, which a destination's header reads as a secret`);
+      }
+    }
+  }
+  return resolved;
+}
+function parseUpstream(value, key, fail) {
+  if (typeof value !== "string") fail(key, "must be an https:// address");
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    fail(key, `${JSON.stringify(value)} is not an https:// address`);
+  }
+  if (url.protocol !== "https:") fail(key, `${JSON.stringify(value)} is not an https:// address: a destination's secret is only ever sent over TLS`);
+  if (url.username !== "" || url.password !== "") fail(key, "must not carry a login; the credential goes in the header");
+  if (url.search !== "" || url.hash !== "") fail(key, "must not carry a query or a fragment");
+  return url.href;
+}
+function parseHeader(value, key, fail) {
+  if (typeof value !== "string") fail(key, 'must be a string such as "Authorization: Bearer ${NPM_TOKEN}"');
+  const colon = value.indexOf(":");
+  if (colon === -1) fail(key, 'must be "Name: value", with a colon');
+  const name = value.slice(0, colon).trim();
+  const text = value.slice(colon + 1).trim();
+  if (!HEADER_NAME.test(name)) fail(key, `names the header ${JSON.stringify(name)}, which is not a header name`);
+  if (text === "") fail(key, "has an empty value");
+  if (/[\r\n\0]/.test(text)) fail(key, "has a value with a line break in it");
+  const variables = [...new Set([...text.matchAll(HEADER_VARIABLE)].map((m) => m[1]))];
+  return { name, value: text, variables };
+}
+function parseEnv(value, key, isReserved, fail) {
+  if (value === void 0) return {};
+  if (typeof value !== "object" || value === null || Array.isArray(value)) fail(key, "must be an object of variable names and values");
+  const env = {};
+  for (const [name, text] of Object.entries(value)) {
+    if (!VARIABLE_NAME.test(name)) fail(key, `names ${JSON.stringify(name)}, which is not a variable name`);
+    if (isReserved(name)) fail(key, `names ${name}, which the runner sets itself`);
+    if (typeof text !== "string") fail(key, `gives ${name} a value that is not a string`);
+    env[name] = text;
+  }
+  return env;
+}
+function destinationEnvironment(destinations, localFor) {
+  const env = {};
+  for (const [index, destination] of (destinations ?? []).entries()) {
+    for (const [name, value] of Object.entries(destination.env)) env[name] = value.split("{local}").join(localFor(index));
+  }
+  return env;
+}
+function containerLocalAddress(index) {
+  return `http://127.0.0.1:${DESTINATION_BASE_PORT + index}/`;
+}
+function destinationSocketPath(buildDir, index) {
+  return join(buildDir, `dest-${index}.sock`);
+}
+function respond(res, status, body) {
+  if (res.headersSent) {
+    res.destroy();
+    return;
+  }
+  res.writeHead(status, { "Content-Type": "text/plain", "Content-Length": Buffer.byteLength(body), Connection: "close" });
+  res.end(body);
+}
+function expandHeader(header, env) {
+  for (const name of header.variables) {
+    if (env[name] === void 0 || env[name] === "") return { missing: name };
+  }
+  return { value: header.value.replace(HEADER_VARIABLE, (_match, name) => env[name]) };
+}
+async function startDestination(input) {
+  const { destination, hostEnv } = input;
+  const upstream = new URL(destination.upstream);
+  const prefix = upstream.pathname.replace(/\/+$/, "");
+  const secure = upstream.protocol === "https:";
+  const send = input.request ?? (secure ? request : request$1);
+  const headerName = destination.header.name.toLowerCase();
+  const dropped = /* @__PURE__ */ new Set(["host", "authorization", "proxy-authorization", "cookie", "connection", "proxy-connection", "keep-alive", "transfer-encoding", "upgrade", ...input.drop ?? []]);
+  const handle = (req, res) => {
+    const target = req.url ?? "";
+    if (!target.startsWith("/")) {
+      respond(res, 400, "send an origin-form request path\n");
+      return;
+    }
+    const expanded = expandHeader(destination.header, hostEnv);
+    if ("missing" in expanded) {
+      respond(res, 502, `the destination ${destination.name} cannot be reached: ${expanded.missing} is not set in the runner's environment
+`);
+      return;
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(req.headers)) {
+      if (!dropped.has(name)) headers[name] = value;
+    }
+    headers.host = upstream.host;
+    headers[headerName] = expanded.value;
+    let forwarded;
+    try {
+      forwarded = send(
+        {
+          protocol: upstream.protocol,
+          hostname: upstream.hostname,
+          port: upstream.port === "" ? secure ? 443 : 80 : Number(upstream.port),
+          method: req.method,
+          path: `${prefix}${target}`,
+          headers,
+          ...input.ca === void 0 ? {} : { ca: input.ca }
+        },
+        (answer) => {
+          res.writeHead(answer.statusCode ?? 502, answer.headers);
+          answer.on("error", () => res.destroy());
+          answer.on("close", () => {
+            if (!answer.complete) res.destroy();
+          });
+          answer.pipe(res);
+        }
+      );
+    } catch {
+      respond(res, 502, `the destination ${destination.name} cannot be reached: its header value was refused
+`);
+      return;
+    }
+    input.onUsed?.(destination.name);
+    forwarded.setTimeout(UPSTREAM_IDLE_MS, () => forwarded.destroy());
+    res.on("close", () => forwarded.destroy());
+    forwarded.on("error", () => respond(res, 502, `the upstream of the destination ${destination.name} could not be reached
+`));
+    req.pipe(forwarded);
+  };
+  const sockets = /* @__PURE__ */ new Set();
+  const server = createServer(handle);
+  server.on("connection", (socket) => {
+    sockets.add(socket);
+    socket.on("close", () => sockets.delete(socket));
+  });
+  const listeners = [server];
+  const served = {};
+  if (input.socketPath !== void 0) {
+    if (Buffer.byteLength(input.socketPath) > MAX_SOCKET_PATH_BYTES) {
+      throw new Error(`${input.socketPath} is too long for a Unix socket; keep the runner's config file nearer the root of the filesystem`);
+    }
+    if (existsSync(input.socketPath)) unlinkSync(input.socketPath);
+    await new Promise((resolve, reject) => {
+      server.once("error", reject);
+      server.listen(input.socketPath, () => resolve());
+    });
+    chmodSync(input.socketPath, 438);
+    served.socketPath = input.socketPath;
+  }
+  if (input.port !== void 0) {
+    const tcp = createServer$1((socket) => server.emit("connection", socket));
+    await new Promise((resolve, reject) => {
+      tcp.once("error", reject);
+      tcp.listen(input.port, "127.0.0.1", () => resolve());
+    });
+    listeners.push(tcp);
+    const address = tcp.address();
+    served.port = address.port;
+  }
+  const close = async () => {
+    for (const socket of sockets) socket.destroy();
+    await Promise.all(listeners.map((listener) => new Promise((resolve) => listener.close(() => resolve()))));
+  };
+  return { ...served, close };
+}
+async function startBuildServices(input) {
+  const tunnel = await input.startTunnel(join(input.buildDir, "tunnel.sock"), {
+    ...input.tunnelOptions,
+    ...input.allowHosts === void 0 ? {} : { allowHosts: input.allowHosts },
+    recordPath: join(input.jobDir, "tunnel.json")
+  });
+  const servers = [];
+  const closeAll = async () => {
+    await Promise.all(servers.map((s) => s.close()));
+    await tunnel.close();
+  };
+  try {
+    let proxyPort;
+    if (input.proxy === true) proxyPort = (await tunnel.listenTcp({ host: "127.0.0.1", port: input.ports?.proxy ?? 0 })).port;
+    const destinationPorts = [];
+    const builtInPorts = {};
+    for (const [index, destination] of input.destinations.entries()) {
+      const server = await startDestination({
+        destination,
+        ...input.serve === "tcp" ? {} : { socketPath: destinationSocketPath(input.buildDir, index) },
+        ...input.serve === "socket" ? {} : { port: input.ports?.destinations?.[index] ?? 0 },
+        hostEnv: input.hostEnv,
+        onUsed: (name) => tunnel.destinationUsed(name),
+        ...input.destinationOptions
+      });
+      servers.push(server);
+      if (server.port !== void 0) destinationPorts.push(server.port);
+    }
+    const builtIns = input.builtIns === void 0 ? [] : builtInDestinations({ gatewayUrl: input.builtIns.gatewayUrl, itemKey: input.builtIns.itemKey, hostEnv: input.hostEnv, claudeUpstream: input.builtIns.claudeUpstream });
+    for (const builtIn of builtIns) {
+      const server = await startDestination({
+        destination: builtIn.destination,
+        ...input.serve === "tcp" ? {} : { socketPath: join(input.buildDir, builtIn.socket) },
+        ...input.serve === "socket" ? {} : { port: input.ports?.builtIns?.[builtIn.destination.name] ?? 0 },
+        hostEnv: builtIn.hostEnv,
+        drop: builtIn.drop,
+        onUsed: (name) => tunnel.destinationUsed(name),
+        ...input.destinationOptions
+      });
+      servers.push(server);
+      if (server.port !== void 0) builtInPorts[builtIn.destination.name] = server.port;
+    }
+    return { ...tunnel, proxyPort, destinationPorts, builtInPorts, close: closeAll };
+  } catch (err) {
+    await closeAll();
+    throw err;
+  }
+}
+
+// src/runner/commit-identity.ts
+var NOREPLY_SUFFIX = "@users.noreply.github.com";
+var MAX_LENGTH = 200;
+function parseIdentity(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const { name, email } = value;
+  if (typeof name !== "string" || typeof email !== "string") return void 0;
+  if (name.trim() === "" || name.length > MAX_LENGTH || /[\r\n\0<>]/.test(name)) return void 0;
+  if (email.length > MAX_LENGTH || !email.endsWith(NOREPLY_SUFFIX) || /[\s\0<>]/.test(email) || email.length === NOREPLY_SUFFIX.length) return void 0;
+  return { name, email };
+}
+function parseClaimIdentity(data) {
+  const author = parseIdentity(data.commitAuthor);
+  if (author === void 0) return void 0;
+  const coAuthor = parseIdentity(data.coAuthor);
+  return coAuthor === void 0 ? { author } : { author, coAuthor };
+}
+function authorEnvironment(identity) {
+  if (identity === void 0) return {};
+  return {
+    GIT_AUTHOR_NAME: identity.name,
+    GIT_AUTHOR_EMAIL: identity.email,
+    GIT_COMMITTER_NAME: identity.name,
+    GIT_COMMITTER_EMAIL: identity.email
+  };
+}
+function configCount(env) {
+  const raw = String(env.GIT_CONFIG_COUNT);
+  return /^[0-9]+$/.test(raw) ? Number(raw) : 0;
+}
+function withHooksPath(env, dir) {
+  const at = configCount(env);
+  return {
+    ...env,
+    GIT_CONFIG_COUNT: String(at + 1),
+    [`GIT_CONFIG_KEY_${at}`]: "core.hooksPath",
+    [`GIT_CONFIG_VALUE_${at}`]: dir
+  };
+}
+function commitIdentityRecord(identity) {
+  return {
+    author: identity === void 0 ? "host" : "app",
+    coAuthor: identity?.coAuthor !== void 0 && identity.hooksPath !== void 0 ? "credited" : "none"
+  };
+}
+
+// src/runner/container/environment.ts
+var RELAY_PORT = 3128;
+var JOB_MOUNT = "/outerlayer/job";
+var CHECKOUT_DIR = "/build/work/checkout";
+var MAX_HOSTS = 200;
+function tokenVariables() {
+  return ["GH_TOKEN", "GITHUB_TOKEN", "GH_ENTERPRISE_TOKEN", "GITHUB_ENTERPRISE_TOKEN"];
+}
+function githubVariables() {
+  return /* @__PURE__ */ new Set([...tokenVariables(), "GH_CONFIG_DIR", "GH_REPO", "GH_NO_UPDATE_NOTIFIER"]);
+}
+var PROXY_URL = `http://127.0.0.1:${RELAY_PORT}`;
+var NO_LOCAL = "localhost,127.0.0.1";
+function proxyEnvironment(proxyUrl, alsoNoProxy) {
+  const NO_PROXY = alsoNoProxy === void 0 || NO_LOCAL.split(",").includes(alsoNoProxy) ? NO_LOCAL : `${NO_LOCAL},${alsoNoProxy}`;
+  return {
+    HTTPS_PROXY: proxyUrl,
+    HTTP_PROXY: proxyUrl,
+    // curl and git read the lowercase forms.
+    https_proxy: proxyUrl,
+    http_proxy: proxyUrl,
+    NO_PROXY,
+    no_proxy: NO_PROXY,
+    NODE_USE_ENV_PROXY: "1",
+    // Yarn 2 and later ignore the variables above and read only their own.
+    // Without these, `yarn install` resolves registry names itself, which a
+    // build with no network of its own cannot do.
+    YARN_HTTPS_PROXY: proxyUrl,
+    YARN_HTTP_PROXY: proxyUrl
+  };
+}
+function runnerLiterals(repository) {
+  return {
+    OUTERLAYER_JOB_DIR: JOB_MOUNT,
+    HOME: "/build/home",
+    TMPDIR: "/tmp",
+    ...proxyEnvironment(PROXY_URL),
+    GIT_TERMINAL_PROMPT: "0",
+    GH_CONFIG_DIR: `${JOB_MOUNT}/gh`,
+    GH_NO_UPDATE_NOTIFIER: "1",
+    ...repository === void 0 ? {} : { GH_REPO: repository }
+  };
+}
+function containerBuiltInAddress(name) {
+  return `http://127.0.0.1:${name === GATEWAY_DESTINATION ? GATEWAY_PORT : CLAUDE_PORT}`;
+}
+function reservedNames() {
+  return /* @__PURE__ */ new Set([
+    ...Object.keys(runnerLiterals("owner/name")),
+    ...Object.keys(builtInEnvironment(containerBuiltInAddress, void 0)),
+    "PATH",
+    ...tokenVariables()
+  ]);
+}
+function isReservedVariable(name) {
+  return name.startsWith("OUTERLAYER_") || reservedNames().has(name);
+}
+function isRefusedInConfig(name) {
+  return isReservedVariable(name) && !githubVariables().has(name);
+}
+function buildEnvironment(input) {
+  const authored = authorEnvironment(input.identity?.author);
+  const recipe = {};
+  for (const [name, value] of Object.entries(input.containerEnv)) {
+    if (!isReservedVariable(name) && !(name in authored)) recipe[name] = value;
+  }
+  const builtIns = input.builtIns === true;
+  const passed = {
+    ...builtIns ? {} : { OUTERLAYER_URL: input.config.url },
+    ...builtIns || input.itemKey === void 0 ? {} : { OUTERLAYER_API_KEY: input.itemKey },
+    OUTERLAYER_APP_ID: input.config.appId,
+    OUTERLAYER_WORK: String(input.item),
+    ...input.branch === void 0 ? {} : { OUTERLAYER_BRANCH: input.branch }
+  };
+  const variables = [];
+  const skippedTokenVariables = [];
+  for (const name of input.config.build?.variables ?? []) {
+    if (tokenVariables().includes(name)) {
+      skippedTokenVariables.push(name);
+      continue;
+    }
+    const value = input.hostEnv[name];
+    if (value === void 0 || isReservedVariable(name) || name in authored) continue;
+    if (builtIns && CLAUDE_CREDENTIAL_VARIABLES.includes(name)) continue;
+    passed[name] = value;
+    variables.push(name);
+  }
+  const destinations = destinationEnvironment(input.config.build?.destinations, containerLocalAddress);
+  const builtInLiterals = builtIns ? builtInEnvironment(containerBuiltInAddress, claudeCredential(input.hostEnv)) : {};
+  const hooksPath = input.identity?.hooksPath;
+  const hooks = {};
+  if (hooksPath !== void 0) {
+    const extended = withHooksPath({ ...recipe, ...passed }, hooksPath);
+    const at = Number(extended.GIT_CONFIG_COUNT) - 1;
+    Object.assign(hooks, {
+      GIT_CONFIG_COUNT: extended.GIT_CONFIG_COUNT,
+      [`GIT_CONFIG_KEY_${at}`]: "core.hooksPath",
+      [`GIT_CONFIG_VALUE_${at}`]: hooksPath
+    });
+    delete passed.GIT_CONFIG_COUNT;
+  }
+  return {
+    literals: { ...recipe, ...destinations, ...runnerLiterals(input.repository), ...builtInLiterals, ...authored, ...hooks },
+    passed,
+    variables,
+    skippedTokenVariables
+  };
+}
+function parseIsolation(value) {
+  return value === "container" || value === "vm" ? value : "shared-user";
+}
+function capHosts(hosts, alsoReached = 0) {
+  const distinct = [...new Set(hosts)];
+  const hostsReached = distinct.slice(0, MAX_HOSTS);
+  return { hostsReached, hostsReachedMore: distinct.length - hostsReached.length + alsoReached };
+}
+function sharedUserEnvironment(cliVersion) {
+  return { isolation: "shared-user", cliVersion };
+}
+var MAX_TEXT = 255;
+var MAX_IGNORED = 500;
+function sendableIgnored(list) {
+  if (list === void 0) return void 0;
+  const fits = (text) => text.length >= 1 && text.length <= MAX_TEXT;
+  return list.filter((entry) => fits(entry.property) && fits(entry.source)).slice(0, MAX_IGNORED);
+}
+function withTunnelRecord(environment, record, onlyWhenUsed = false) {
+  const ignoredProperties = sendableIgnored(environment.ignoredProperties);
+  const base = ignoredProperties === void 0 ? environment : { ...environment, ignoredProperties };
+  if (record === void 0) return base;
+  const used = record.hosts.length + record.hostsMore + record.refusals.length + record.refusalsMore + (record.destinations?.length ?? 0) > 0;
+  if (onlyWhenUsed && !used) return base;
+  return {
+    ...base,
+    ...capHosts(record.hosts, record.hostsMore),
+    refusals: record.refusals.slice(0, MAX_HOSTS),
+    refusalsMore: Math.max(0, record.refusals.length - MAX_HOSTS) + record.refusalsMore,
+    ...record.destinations === void 0 || record.destinations.length === 0 ? {} : { destinations: record.destinations }
+  };
+}
+
+export { AGENT_CREDENTIAL_MISSING, BUILT_IN_NAMES, CHECKOUT_DIR, CLAUDE_CREDENTIAL_VARIABLES, CLAUDE_PORT, CLAUDE_SOCKET, DESTINATION_BASE_PORT, GATEWAY_PORT, GATEWAY_SOCKET, JOB_MOUNT, RELAY_PORT, authorEnvironment, buildEnvironment, builtInEnvironment, claudeCredential, commitIdentityRecord, containerLocalAddress, destinationEnvironment, headerVariables, isRefusedInConfig, isReservedVariable, parseClaimIdentity, parseIsolation, proxyEnvironment, resolveDestinations, sharedUserEnvironment, startBuildServices, withHooksPath, withTunnelRecord };

package/dist/chunk-B2G7JHHB.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { RELAY_PORT, GATEWAY_SOCKET, GATEWAY_PORT, CLAUDE_SOCKET, CLAUDE_PORT, DESTINATION_BASE_PORT } from './chunk-AUFG23AA.js';
+import { symlinkSync, unlinkSync } from 'fs';
+import { join } from 'path';
+
+createRequire(import.meta.url);
+var EXEC_PORT = 1024;
+var GUEST_CID = 3;
+var MAX_SOCKET_PATH = 107;
+function vsockLinks(input) {
+  return [
+    { port: RELAY_PORT, socket: "tunnel.sock" },
+    ...Array.from({ length: input.destinations }, (_unused, index) => ({ port: DESTINATION_BASE_PORT + index, socket: `dest-${index}.sock` })),
+    ...input.builtIns ? [
+      { port: GATEWAY_PORT, socket: GATEWAY_SOCKET },
+      { port: CLAUDE_PORT, socket: CLAUDE_SOCKET }
+    ] : []
+  ];
+}
+function linkVsockSockets(input) {
+  for (const { port, socket } of input.links) {
+    const link = `${input.vsockPath}_${port}`;
+    removeLink(link);
+    symlinkSync(join(input.buildDir, socket), link);
+  }
+}
+function removeLink(link) {
+  try {
+    unlinkSync(link);
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+}
+var LONGEST_SUFFIX = "/v.sock_65535";
+function socketPathProblem(buildDir) {
+  const longest = Buffer.byteLength(`${buildDir}${LONGEST_SUFFIX}`);
+  if (longest <= MAX_SOCKET_PATH) return void 0;
+  return `the build directory ${buildDir} is too deep for the microVM's sockets: a socket path holds at most ${MAX_SOCKET_PATH} bytes and the longest here is ${longest}; move the runner's config file closer to the root`;
+}
+
+export { EXEC_PORT, GUEST_CID, linkVsockSockets, socketPathProblem, vsockLinks };

package/dist/chunk-BCJNHMZT.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { readLaunchSpoolState, launchesPath } from './chunk-DVDEBNQJ.js';
+
+createRequire(import.meta.url);
+
+// src/launch-filter.ts
+function launchRefusalForSession(sessionId, home) {
+  const spool = readLaunchSpoolState(home);
+  if (spool.ids.has(sessionId)) return void 0;
+  if (spool.unreadable !== void 0) {
+    return `the launch spool at ${launchesPath(home)} could not be read (${spool.unreadable}), so this session's launch could not be checked and nothing it produces may leave the machine. Fix the file's permissions and re-run.`;
+  }
+  if (spool.malformedLines !== void 0) {
+    return `the launch spool at ${launchesPath(home)} has ${spool.malformedLines} damaged line(s), so this session's launch could not be checked and nothing it produces may leave the machine.`;
+  }
+  return `this session was not launched with OUTERLAYER_WORK naming a work item, so nothing it produces may leave the machine. Start the session with OUTERLAYER_WORK set (for example OUTERLAYER_WORK=42), or run this from CI.`;
+}
+var LaunchFilter = class {
+  constructor(launchedSessionIds) {
+    this.launchedSessionIds = launchedSessionIds;
+    /** Sessions dropped for carrying no launch record — for the sync summary. */
+    this.skippedTotal = 0;
+  }
+  /** True when the session should sync. Records skips for reporting. */
+  allows(session) {
+    const key = session.subagent?.parentSessionId ?? session.id;
+    const allowed = typeof key === "string" && this.launchedSessionIds.has(key);
+    if (!allowed) this.skippedTotal += 1;
+    return allowed;
+  }
+};
+
+export { LaunchFilter, launchRefusalForSession };

package/dist/chunk-BCLJSQCV.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { readCloudConfig, cloudConfigPath } from './chunk-EABW6AJQ.js';
+import { signRunnerRequest, signerFor } from './chunk-M5POMKKW.js';
+import { homeFromEnv } from './chunk-VNVZDWO3.js';
+
+createRequire(import.meta.url);
+
+// src/signing-fetch.ts
+function bodyBytes(body) {
+  if (body === void 0 || body === null) return new Uint8Array(0);
+  if (typeof body === "string") return new TextEncoder().encode(body);
+  if (body instanceof Uint8Array) return body;
+  if (body instanceof ArrayBuffer) return new Uint8Array(body);
+  return void 0;
+}
+async function savedKeySigner(headers, home) {
+  const authorization = headers.get("authorization");
+  if (authorization === null || !authorization.startsWith("Bearer ")) return void 0;
+  if (headers.has("signature")) return void 0;
+  if (readCloudConfig(home).apiKey !== authorization.slice("Bearer ".length)) return void 0;
+  try {
+    return await signerFor(cloudConfigPath(home));
+  } catch {
+    return void 0;
+  }
+}
+function signedBy(base, signerOf) {
+  return (async (input, init) => {
+    if (input instanceof Request) return base(input, init);
+    const headers = new Headers(init?.headers);
+    const signer = await signerOf(headers);
+    const body = bodyBytes(init?.body);
+    if (signer === void 0 || body === void 0) return base(input, init);
+    const signature = await signRunnerRequest({ method: init?.method ?? "GET", url: input.toString(), body, signer });
+    for (const [name, value] of Object.entries(signature)) headers.set(name, value);
+    return base(input, { ...init, headers });
+  });
+}
+function signingFetch(base, home = () => homeFromEnv()) {
+  return signedBy(base, (headers) => savedKeySigner(headers, home()));
+}
+function signingFetchFor(base, configPath, apiKey) {
+  return signedBy(base, async (headers) => {
+    const authorization = headers.get("authorization");
+    if (authorization !== `Bearer ${apiKey}` || headers.has("signature")) return void 0;
+    try {
+      return await signerFor(configPath);
+    } catch {
+      return void 0;
+    }
+  });
+}
+var defaultFetch = signingFetch((input, init) => globalThis.fetch(input, init));
+
+export { defaultFetch, signingFetchFor };