@outerlayer/cli 0.1.0

package/dist/chunk-OZ7C3XUE.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { readFileSync } from 'fs';
+import { execFileSync } from 'child_process';
+
+createRequire(import.meta.url);
+function startTimeOf(pid) {
+  if (process.platform === "linux") return startTimeOfLinux(pid);
+  return startTimeOfPs(pid);
+}
+function startTimeOfLinux(pid) {
+  try {
+    const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
+    const afterComm = stat.slice(stat.lastIndexOf(")") + 1).trim();
+    const fields = afterComm.split(/\s+/);
+    const starttime = fields[19];
+    return starttime ?? null;
+  } catch {
+    return null;
+  }
+}
+function startTimeOfPs(pid) {
+  try {
+    const out = execFileSync("ps", ["-o", "lstart=", "-p", String(pid)], { encoding: "utf8" }).trim();
+    return out.length > 0 ? out : null;
+  } catch {
+    return null;
+  }
+}
+function isSameProcess(pid, start) {
+  return startTimeOf(pid) === start;
+}
+
+export { isSameProcess, startTimeOf };

package/dist/chunk-RCQXYLMO.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { mkdirSync, appendFileSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+createRequire(import.meta.url);
+
+// src/tracker-number.ts
+var MAX_TRACKER_NUMBER = Number.MAX_SAFE_INTEGER;
+function parseTrackerNumber(raw) {
+  if (raw === void 0) return void 0;
+  const text = typeof raw === "number" ? String(raw) : raw;
+  if (!/^\d+$/.test(text)) return void 0;
+  const n = Number(text);
+  if (!Number.isSafeInteger(n) || n <= 0) return void 0;
+  return n;
+}
+function trackerNumberError(flag, raw) {
+  return `invalid ${flag} "${raw}" \u2014 expected a positive integer no larger than ${MAX_TRACKER_NUMBER}`;
+}
+
+// src/work-launch.ts
+var HOW_TO_CREATE_AN_ITEM = "outerlayer work add";
+function parseWorkItemEnv(raw) {
+  if (raw === void 0) return { reason: "OUTERLAYER_WORK is not set" };
+  const value = raw.trim();
+  if (value === "" || value.toLowerCase() === "on") {
+    return {
+      reason: `OUTERLAYER_WORK=${JSON.stringify(raw)} does not name a work item \u2014 create one with \`${HOW_TO_CREATE_AN_ITEM}\` and pass its number`
+    };
+  }
+  const number = parseTrackerNumber(value);
+  if (number === void 0) {
+    return {
+      reason: `OUTERLAYER_WORK="${value}" does not name a work item \u2014 it must be a bare positive integer, the number \`${HOW_TO_CREATE_AN_ITEM}\` prints when the item is created`
+    };
+  }
+  return { number };
+}
+function launchesPath(home) {
+  return join(home, ".outerlayer", "spool", "launches.jsonl");
+}
+function appendLaunchRecord(input, home) {
+  mkdirSync(join(home, ".outerlayer", "spool"), { recursive: true });
+  const record = { sessionId: input.sessionId, item: input.item, t: input.t ?? (/* @__PURE__ */ new Date()).toISOString() };
+  appendFileSync(launchesPath(home), `${JSON.stringify(record)}
+`);
+}
+var readLaunchSpool = (path) => {
+  try {
+    return { kind: "read", text: readFileSync(path, "utf8") };
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") return { kind: "absent" };
+    return { kind: "unreadable", reason: err instanceof Error ? err.message : String(err) };
+  }
+};
+function launchStatusIsDecisive(state) {
+  return state.unreadable === void 0 && state.malformedLines === void 0;
+}
+function launchedItemForSession(sessionId, home, readImpl = readLaunchSpool) {
+  const read = readImpl(launchesPath(home));
+  if (read.kind !== "read") return void 0;
+  let found;
+  for (const line of read.text.split("\n")) {
+    try {
+      const record = JSON.parse(line);
+      if (record.sessionId === sessionId && typeof record.item === "number") {
+        found = record.item;
+      }
+    } catch {
+    }
+  }
+  return found;
+}
+function readLaunchSpoolState(home, readImpl = readLaunchSpool) {
+  const ids = /* @__PURE__ */ new Set();
+  const read = readImpl(launchesPath(home));
+  if (read.kind === "unreadable") return { ids, unreadable: read.reason };
+  if (read.kind === "absent") return { ids };
+  let malformedLines = 0;
+  for (const line of read.text.split("\n")) {
+    const text = line.trim();
+    if (!text) continue;
+    try {
+      const record = JSON.parse(text);
+      if (typeof record.sessionId === "string" && record.sessionId !== "") ids.add(record.sessionId);
+      else malformedLines += 1;
+    } catch {
+      malformedLines += 1;
+    }
+  }
+  return { ids, ...malformedLines > 0 ? { malformedLines } : {} };
+}
+
+export { appendLaunchRecord, launchStatusIsDecisive, launchedItemForSession, launchesPath, parseTrackerNumber, parseWorkItemEnv, readLaunchSpoolState, trackerNumberError };

package/dist/chunk-TFUIDMOB.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { homeFromEnv } from './chunk-VNVZDWO3.js';
+import { existsSync, readFileSync, mkdirSync, writeFileSync, chmodSync } from 'fs';
+import { join } from 'path';
+
+createRequire(import.meta.url);
+function cloudConfigPath(home = homeFromEnv()) {
+  return join(home, ".outerlayer", "config.json");
+}
+function readCloudConfig(home = homeFromEnv()) {
+  const path = cloudConfigPath(home);
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeCloudConfig(config, home = homeFromEnv()) {
+  const path = cloudConfigPath(home);
+  const merged = { ...readCloudConfig(home) };
+  for (const [key, value] of Object.entries(config)) {
+    if (value !== void 0) merged[key] = value;
+  }
+  mkdirSync(join(path, ".."), { recursive: true });
+  writeFileSync(path, JSON.stringify(merged, null, 2) + "\n", { mode: 384 });
+  try {
+    chmodSync(path, 384);
+  } catch {
+  }
+}
+
+export { cloudConfigPath, readCloudConfig, writeCloudConfig };

package/dist/chunk-VNVZDWO3.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { homedir } from 'os';
+
+createRequire(import.meta.url);
+function homeFromEnv(env = process.env) {
+  return env.HOME || homedir();
+}
+
+export { homeFromEnv };

package/dist/chunk-VU34RWDU.js

@@ -0,0 +1,339 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { resolveRepoIdentity, detectActiveSession } from './chunk-DEDV5V4U.js';
+import { parseTrackerNumber, trackerNumberError } from './chunk-RCQXYLMO.js';
+import { readCloudConfig } from './chunk-TFUIDMOB.js';
+import { homeFromEnv } from './chunk-VNVZDWO3.js';
+
+createRequire(import.meta.url);
+
+// src/work-cmd.ts
+var GREEN = "\x1B[32m";
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+var WorkCommandError = class extends Error {
+  /** True when the same request is worth sending again: the gateway was
+   * unreachable, answered a body that never came from it, or failed in a way
+   * that is about the moment rather than the request (5xx, 429). A refusal
+   * (401, an unknown repository, a malformed subject) is not.
+   *
+   * `status` is the response's own status, absent when the request never
+   * reached a response. A caller that has to tell one refusal from another —
+   * a claim lost to another host from a key that no longer works — reads it
+   * rather than matching on the message. */
+  constructor(message, retryable = false, status) {
+    super(message);
+    this.retryable = retryable;
+    this.status = status;
+  }
+};
+var WORK_ADD_RETRY_DELAYS_MS = [1e3, 5e3, 15e3, 6e4];
+function resolveCredentials(opts) {
+  const home = opts.home ?? homeFromEnv();
+  const env = opts.env ?? process.env;
+  const fileConfig = readCloudConfig(home);
+  const url = opts.url ?? env.OUTERLAYER_URL ?? fileConfig.url;
+  const apiKey = opts.apiKey ?? env.OUTERLAYER_API_KEY ?? fileConfig.apiKey;
+  const appId = opts.appId ?? env.OUTERLAYER_APP_ID ?? fileConfig.appId;
+  if (!url || !apiKey || !appId) {
+    const missing = [!url && "--url", !apiKey && "--api-key", !appId && "--app-id"].filter(Boolean).join(", ");
+    throw new WorkCommandError(
+      `missing ${missing}. Run \`outerlayer login --url <your gateway>\` and paste the key at the prompt, or set OUTERLAYER_URL / OUTERLAYER_API_KEY / OUTERLAYER_APP_ID. Mint a key in the dashboard: Settings \u2192 API keys.`
+    );
+  }
+  return { url, apiKey, appId };
+}
+function resolveRepository(repoFlag, cwd) {
+  if (repoFlag) return repoFlag;
+  const identity = resolveRepoIdentity(cwd);
+  if (identity.gitRepo) return identity.gitRepo;
+  throw new WorkCommandError(
+    "no repository. Pass --repo <owner/name>, or run from a git checkout with a remote."
+  );
+}
+function parsePositiveInt(raw, flag) {
+  if (raw === void 0) return void 0;
+  const n = parseTrackerNumber(raw);
+  if (n === void 0) throw new WorkCommandError(trackerNumberError(flag, raw));
+  return n;
+}
+function parseRetries(raw) {
+  const n = parseTrackerNumber(raw);
+  return n === void 0 ? 0 : Math.min(n, WORK_ADD_RETRY_DELAYS_MS.length);
+}
+function resolveSubject(opts) {
+  const issue = parsePositiveInt(opts.issue, "--issue");
+  if (issue === void 0) {
+    throw new WorkCommandError("pass --issue");
+  }
+  return { issue };
+}
+async function postJson(url, path, apiKey, appId, body, fetchImpl) {
+  let response;
+  const endpoint = new URL(path, url).toString();
+  try {
+    response = await fetchImpl(endpoint, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${apiKey}`,
+        "x-outerlayer-app-id": appId
+      },
+      body: JSON.stringify(body)
+    });
+  } catch (err) {
+    throw new WorkCommandError(`network error reaching ${endpoint}: ${String(err)}`, true);
+  }
+  if (response.status === 401) {
+    throw new WorkCommandError(
+      "not authorized \u2014 the API key is unknown, expired, or bound to a different app. Mint a fresh key: dashboard \u2192 Settings \u2192 API keys.",
+      false,
+      401
+    );
+  }
+  let json;
+  try {
+    json = await response.json();
+  } catch {
+    throw new WorkCommandError(
+      `${endpoint} answered ${response.status} with a body that is not JSON \u2014 the request may not have reached the gateway`,
+      true,
+      response.status
+    );
+  }
+  if (!response.ok) {
+    throw new WorkCommandError(
+      json.error?.message ?? `request failed (${response.status})`,
+      response.status >= 500 || response.status === 429,
+      response.status
+    );
+  }
+  return { status: response.status, data: json.data ?? json };
+}
+async function getJson(url, path, apiKey, appId, fetchImpl) {
+  const endpoint = new URL(path, url).toString();
+  let response;
+  try {
+    response = await fetchImpl(endpoint, {
+      method: "GET",
+      headers: { authorization: `Bearer ${apiKey}`, "x-outerlayer-app-id": appId }
+    });
+  } catch (err) {
+    throw new WorkCommandError(`network error reaching ${endpoint}: ${String(err)}`);
+  }
+  if (response.status === 401) {
+    throw new WorkCommandError(
+      "not authorized \u2014 the API key is unknown, expired, or bound to a different app. Mint a fresh key: dashboard \u2192 Settings \u2192 API keys.",
+      false,
+      401
+    );
+  }
+  let json;
+  try {
+    json = await response.json();
+  } catch {
+    throw new WorkCommandError(
+      `${endpoint} answered ${response.status} with a body that is not JSON \u2014 the request may not have reached the gateway`,
+      true,
+      response.status
+    );
+  }
+  if (!response.ok) {
+    throw new WorkCommandError(
+      json.error?.message ?? `request failed (${response.status})`,
+      response.status >= 500 || response.status === 429,
+      response.status
+    );
+  }
+  return { status: response.status, data: json.data ?? json, pagination: json.pagination ?? null };
+}
+async function findLiveItem(creds, repository, subject, fetchImpl) {
+  const query = new URLSearchParams({ repository, issue: String(subject.issue) });
+  const page = await getJson(
+    creds.url,
+    `/v1/work-items?${query.toString()}`,
+    creds.apiKey,
+    creds.appId,
+    fetchImpl
+  );
+  const items = page.data ?? [];
+  return items[0] ?? null;
+}
+function environmentFacts(opts) {
+  const identity = resolveRepoIdentity(opts.cwd);
+  const sessionId = opts.sessionIdOverride ?? detectActiveSession({
+    env: opts.env,
+    home: opts.home,
+    cwds: identity.repoRoot !== void 0 ? [identity.repoRoot, opts.cwd] : [opts.cwd],
+    nowMs: Date.now()
+  });
+  const ci = opts.env.GITHUB_ACTIONS && opts.env.GITHUB_RUN_ID ? { runId: opts.env.GITHUB_RUN_ID } : void 0;
+  return {
+    ...sessionId !== void 0 ? { sessionId } : {},
+    ...ci ? { ci } : {}
+  };
+}
+async function runWorkAdd(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const env = opts.env ?? process.env;
+  const home = opts.home ?? homeFromEnv(env);
+  const { url, apiKey, appId } = resolveCredentials(opts);
+  const subject = resolveSubject(opts);
+  const repository = resolveRepository(opts.repo, cwd);
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const body = {
+    subject: { repository, ...subject },
+    note: opts.note,
+    ...environmentFacts({ cwd, env, home, sessionIdOverride: opts.sessionId })
+  };
+  const retries = parseRetries(opts.retry);
+  const sleep = opts.sleepImpl ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  let data;
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      data = (await postJson(url, "/v1/work-items", apiKey, appId, body, fetchImpl)).data;
+      break;
+    } catch (err) {
+      if (attempt >= retries || !(err instanceof WorkCommandError) || !err.retryable) throw err;
+      await sleep(WORK_ADD_RETRY_DELAYS_MS[attempt]);
+    }
+  }
+  const stageLine = data.recomputed === false ? `stage ${data.stage} (not yet derived \u2014 the hourly sweep settles it)` : `stage ${data.stage}`;
+  const output = opts.json ? JSON.stringify(data) : `${GREEN}\u2713${RESET} added ${DIM}\xB7${RESET} ${data.number != null ? `#${data.number}` : data.workItemId} ${DIM}\xB7${RESET} attestor ${data.attestor} ${DIM}\xB7${RESET} ${stageLine}`;
+  if (!opts.quiet) process.stdout.write(output + "\n");
+  return { data, output };
+}
+async function runWorkLinkSession(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const env = opts.env ?? process.env;
+  const home = opts.home ?? homeFromEnv(env);
+  const { url, apiKey, appId } = resolveCredentials(opts);
+  const number = parsePositiveInt(opts.number, "number");
+  if (number === void 0) throw new WorkCommandError("pass the item's number");
+  const { sessionId } = environmentFacts({ cwd, env, home, sessionIdOverride: opts.sessionId });
+  if (!sessionId) {
+    throw new WorkCommandError("no session id detected \u2014 pass --session-id or run from a live session");
+  }
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const identity = resolveRepoIdentity(cwd);
+  const body = { sessionId, repository: identity.gitRepo ?? "" };
+  const retries = parseRetries(opts.retry);
+  const sleep = opts.sleepImpl ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  let data;
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      data = (await postJson(url, `/v1/work-items/${number}/sessions`, apiKey, appId, body, fetchImpl)).data;
+      break;
+    } catch (err) {
+      if (attempt >= retries || !(err instanceof WorkCommandError) || !err.retryable) throw err;
+      await sleep(WORK_ADD_RETRY_DELAYS_MS[attempt]);
+    }
+  }
+  const output = opts.json ? JSON.stringify(data) : `${GREEN}\u2713${RESET} linked ${DIM}\xB7${RESET} session ${sessionId} ${DIM}\xB7${RESET} #${number}`;
+  if (!opts.quiet) process.stdout.write(output + "\n");
+  return { data, output };
+}
+async function runWorkRemove(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const env = opts.env ?? process.env;
+  const home = opts.home ?? homeFromEnv(env);
+  const creds = resolveCredentials(opts);
+  if (!opts.reason) {
+    throw new WorkCommandError("--reason is required \u2014 a removal records why");
+  }
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const itemNumber = parsePositiveInt(opts.item, "--item");
+  if (itemNumber !== void 0) {
+    const { data: data2 } = await postJson(
+      creds.url,
+      `/v1/work-items/${itemNumber}/remove`,
+      creds.apiKey,
+      creds.appId,
+      { reason: opts.reason, ...environmentFacts({ cwd, env, home }) },
+      fetchImpl
+    );
+    const output2 = opts.json ? JSON.stringify(data2) : `${GREEN}\u2713${RESET} removed ${DIM}\xB7${RESET} ${data2.workItemId} ${DIM}\xB7${RESET} withdrawn ${data2.itemWithdrawn}`;
+    if (!opts.quiet) process.stdout.write(output2 + "\n");
+    return { data: data2, output: output2 };
+  }
+  const subject = resolveSubject(opts);
+  const repository = resolveRepository(opts.repo, cwd);
+  const number = subject.issue;
+  const item = await findLiveItem(creds, repository, subject, fetchImpl);
+  if (!item) {
+    const data2 = { workItemId: null, removed: true, itemWithdrawn: false, noLiveAddition: true };
+    const output2 = opts.json ? JSON.stringify(data2) : `${GREEN}\u2713${RESET} nothing to remove ${DIM}\xB7${RESET} no live addition on ${repository}#${number}`;
+    if (!opts.quiet) process.stdout.write(output2 + "\n");
+    return { data: data2, output: output2 };
+  }
+  const { data } = await postJson(
+    creds.url,
+    `/v1/work-items/${item.id}/remove`,
+    creds.apiKey,
+    creds.appId,
+    { reason: opts.reason, ...environmentFacts({ cwd, env, home }) },
+    fetchImpl
+  );
+  const output = opts.json ? JSON.stringify(data) : `${GREEN}\u2713${RESET} removed ${DIM}\xB7${RESET} ${data.workItemId} ${DIM}\xB7${RESET} withdrawn ${data.itemWithdrawn}`;
+  if (!opts.quiet) process.stdout.write(output + "\n");
+  return { data, output };
+}
+async function runWorkStatus(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const creds = resolveCredentials(opts);
+  const fetchByItem = opts.item !== void 0 ? parsePositiveInt(opts.item, "--item") : void 0;
+  if (fetchByItem !== void 0) {
+    const { data: data2 } = await getJson(
+      creds.url,
+      `/v1/work-items/${fetchByItem}`,
+      creds.apiKey,
+      creds.appId,
+      opts.fetchImpl ?? fetch
+    );
+    const body = opts.json ? JSON.stringify(data2) : JSON.stringify(data2, null, 2);
+    if (!opts.quiet) process.stdout.write(body + "\n");
+    return { data: data2, output: body };
+  }
+  const subject = resolveSubject(opts);
+  const repository = resolveRepository(opts.repo, cwd);
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const number = subject.issue;
+  const item = await findLiveItem(creds, repository, subject, fetchImpl);
+  if (!item) {
+    throw new WorkCommandError(`no live item for ${repository}#${number}`);
+  }
+  const { data } = await getJson(creds.url, `/v1/work-items/${item.id}`, creds.apiKey, creds.appId, fetchImpl);
+  const output = opts.json ? JSON.stringify(data) : `${JSON.stringify(data, null, 2)}`;
+  if (!opts.quiet) process.stdout.write(output + "\n");
+  return { data, output };
+}
+async function runWorkList(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const { url, apiKey, appId } = resolveCredentials(opts);
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const repository = opts.repo ?? resolveRepoIdentity(cwd).gitRepo;
+  if (opts.needs !== void 0 && opts.needs !== "amend") {
+    throw new WorkCommandError('--needs only accepts "amend"');
+  }
+  const query = new URLSearchParams();
+  if (repository) query.set("repository", repository);
+  if (opts.stage) query.set("stage", opts.stage);
+  if (opts.section) query.set("section", opts.section);
+  if (opts.unclaimed) query.set("unclaimed", "true");
+  if (opts.startable) query.set("startable", "true");
+  if (opts.needs) query.set("needs", opts.needs);
+  const items = [];
+  let cursor = null;
+  do {
+    if (cursor) query.set("cursor", cursor);
+    const page = await getJson(url, `/v1/work-items?${query.toString()}`, apiKey, appId, fetchImpl);
+    if (Array.isArray(page.data)) items.push(...page.data);
+    cursor = page.pagination?.cursor ?? null;
+  } while (cursor);
+  const data = items;
+  const output = opts.json ? JSON.stringify(data) : items.length === 0 ? "no live work items" : items.map((i) => `${i.trackerKey} ${DIM}\xB7${RESET} ${i.stage} ${DIM}\xB7${RESET} ${i.section} ${DIM}\xB7${RESET} ${i.title}`).join("\n");
+  if (!opts.quiet) process.stdout.write(output + "\n");
+  return { data, output };
+}
+
+export { WorkCommandError, findLiveItem, getJson, parsePositiveInt, postJson, resolveCredentials, resolveRepository, runWorkAdd, runWorkLinkSession, runWorkList, runWorkRemove, runWorkStatus };

package/dist/chunk-WQ6VGRGZ.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { homeFromEnv } from './chunk-VNVZDWO3.js';
+import { existsSync, statSync, accessSync, constants, readFileSync } from 'fs';
+import { hostname } from 'os';
+import { join } from 'path';
+
+createRequire(import.meta.url);
+var RUNNER_QUEUES = ["implement", "amend"];
+var RunnerConfigError = class extends Error {
+};
+var DEFAULT_CONCURRENCY = 1;
+var DEFAULT_POLL_SECONDS = 60;
+var DEFAULT_TIME_LIMIT_MINUTES = 480;
+var DEFAULT_IDLE_LIMIT_MINUTES = 30;
+function defaultRunnerConfigPath(home = homeFromEnv()) {
+  return join(home, ".outerlayer", "config.json");
+}
+function fail(configPath, key, reason) {
+  throw new RunnerConfigError(`${configPath}: ${key} ${reason}`);
+}
+function readConfigFile(configPath) {
+  if (!existsSync(configPath)) return {};
+  const text = readFileSync(configPath, "utf8");
+  try {
+    return JSON.parse(text);
+  } catch (err) {
+    throw new RunnerConfigError(
+      `${configPath}: is not valid JSON: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+var RUNNER_KEYS = [
+  "host",
+  "queues",
+  "concurrency",
+  "pollSeconds",
+  "timeLimitMinutes",
+  "idleLimitMinutes",
+  "commands",
+  "hooks"
+];
+var RUNNER_NUMBERS = [
+  { key: "concurrency", min: 1 },
+  // Below five seconds a runner is asking the gateway a question it has
+  // just been answered.
+  { key: "pollSeconds", min: 5 },
+  { key: "timeLimitMinutes", min: 1 },
+  { key: "idleLimitMinutes", min: 1 }
+];
+function nearestKey(unknown, accepted) {
+  const lower = unknown.toLowerCase();
+  let best;
+  for (const key of accepted) {
+    const distance = editDistance(lower, key.toLowerCase());
+    if (distance <= Math.max(1, Math.floor(key.length / 4)) && (!best || distance < best.distance)) {
+      best = { key, distance };
+    }
+  }
+  return best?.key;
+}
+function editDistance(a, b) {
+  const rows = Array.from({ length: a.length + 1 }, (_unused, i) => [i, ...Array(b.length).fill(0)]);
+  for (let j = 0; j <= b.length; j++) rows[0][j] = j;
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      rows[i][j] = Math.min(
+        rows[i - 1][j] + 1,
+        rows[i][j - 1] + 1,
+        rows[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1)
+      );
+    }
+  }
+  return rows[a.length][b.length];
+}
+function checkHooks(config) {
+  const named = [
+    ["runner.hooks.provision", config.hooks.provision],
+    ["runner.hooks.cleanup", config.hooks.cleanup],
+    ["runner.hooks.report", config.hooks.report]
+  ];
+  for (const [key, path] of named) {
+    if (path === void 0) continue;
+    if (path.includes("$") || path.startsWith("~")) {
+      return `${key}: ${path} \u2014 hooks are executable paths, not shell lines; $HOME and ~ are not expanded`;
+    }
+    if (!existsSync(path)) return `${key}: ${path} does not exist`;
+    if (!statSync(path).isFile()) return `${key}: ${path} is not a file`;
+    try {
+      accessSync(path, constants.X_OK);
+    } catch {
+      return `${key}: ${path} is not executable`;
+    }
+  }
+  return void 0;
+}
+function loadRunnerConfig(configPath) {
+  const config = readConfigFile(configPath);
+  if (!config.url || !config.apiKey || !config.appId) {
+    fail(configPath, "url/apiKey/appId", "missing \u2014 run `outerlayer login` against this config file first");
+  }
+  const runner = config.runner;
+  if (!runner) {
+    fail(configPath, "runner", "block is missing");
+  }
+  for (const key of Object.keys(runner)) {
+    if (RUNNER_KEYS.includes(key)) continue;
+    const near = nearestKey(key, RUNNER_KEYS);
+    fail(configPath, `runner.${key}`, near ? `is not a key this block accepts; did you mean ${near}?` : "is not a key this block accepts");
+  }
+  for (const { key, min } of RUNNER_NUMBERS) {
+    const value = runner[key];
+    if (value === void 0) continue;
+    if (typeof value !== "number" || !Number.isInteger(value) || value < min) {
+      fail(configPath, `runner.${key}`, `must be a whole number of at least ${min}`);
+    }
+  }
+  const queues = runner.queues && runner.queues.length > 0 ? runner.queues : [...RUNNER_QUEUES];
+  for (const queue of queues) {
+    if (!RUNNER_QUEUES.includes(queue)) {
+      fail(configPath, "runner.queues", `names an unknown queue "${queue}" \u2014 must be implement or amend`);
+    }
+    if (!runner.commands?.[queue]) {
+      fail(configPath, `runner.commands.${queue}`, "is required for an enabled queue");
+    }
+  }
+  if (!runner.hooks?.provision) fail(configPath, "runner.hooks.provision", "is required");
+  if (!runner.hooks?.cleanup) fail(configPath, "runner.hooks.cleanup", "is required");
+  return {
+    configPath,
+    url: config.url,
+    apiKey: config.apiKey,
+    appId: config.appId,
+    repos: config.repos,
+    host: runner.host ?? hostname(),
+    queues,
+    concurrency: runner.concurrency ?? DEFAULT_CONCURRENCY,
+    pollSeconds: runner.pollSeconds ?? DEFAULT_POLL_SECONDS,
+    timeLimitMinutes: runner.timeLimitMinutes ?? DEFAULT_TIME_LIMIT_MINUTES,
+    idleLimitMinutes: runner.idleLimitMinutes ?? DEFAULT_IDLE_LIMIT_MINUTES,
+    commands: runner.commands ?? {},
+    hooks: {
+      provision: runner.hooks.provision,
+      cleanup: runner.hooks.cleanup,
+      report: runner.hooks.report
+    }
+  };
+}
+
+export { RunnerConfigError, checkHooks, defaultRunnerConfigPath, loadRunnerConfig };