@outerlayer/cli 0.2.0 → 0.4.1

package/dist/agent-setup-IFH3FB5X.js

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { installStarterPack } from './chunk-ZMYPLFG3.js';
+import { runEmit } from './chunk-H5NCNVDA.js';
+import { addStdioMcpEntryIfAbsent } from './chunk-MQ3IPHIZ.js';
+import { C } from './chunk-YRYMNBGQ.js';
+import { resolveGitCommonDir, defaultGitRunner } from './chunk-XDDW4FRS.js';
+import { pinExists, readContextManifest } from './chunk-WIOZAJ2W.js';
+import { loadTemplateFiles, loadMaintainedFiles, skillDir } from './chunk-WO2BXCTQ.js';
+import { generatedHeaderSource } from './chunk-EMY4I27X.js';
+import './chunk-ZJSNLVCE.js';
+import './chunk-BCLJSQCV.js';
+import './chunk-BOLTI6LR.js';
+import './chunk-EABW6AJQ.js';
+import './chunk-RA3O54FC.js';
+import './chunk-M5POMKKW.js';
+import './chunk-ZM2IMMYN.js';
+import './chunk-XCCLFVXM.js';
+import './chunk-BJ3KTMDH.js';
+import './chunk-VNVZDWO3.js';
+import './chunk-Z5GEFMRW.js';
+import { execFileSync } from 'child_process';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join, dirname } from 'path';
+
+createRequire(import.meta.url);
+var CONFIG_PATH = ".outerlayer/config.json";
+var MCP_OUTPUT_PATH = ".mcp.json";
+var POLICY_PATH = ".outerlayer/policy.yaml";
+var DEFAULT_CONFIG = `${JSON.stringify({ targets: ["claude-code"] }, null, 2)}
+`;
+var errorMessage = (err) => err instanceof Error ? err.message : String(err);
+var skipped = (reason) => ({
+  outcome: "skipped",
+  reason,
+  text: `${C.dim}- Agent setup skipped: ${reason}${C.reset}
+`,
+  paths: []
+});
+var GitLookupError = class extends Error {
+};
+function gitTopLevel(cwd) {
+  try {
+    const top = execFileSync("git", ["rev-parse", "--show-toplevel"], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+    return top === "" ? void 0 : top;
+  } catch (err) {
+    const stderr = String(err.stderr ?? "");
+    if (/not a git repository/i.test(stderr)) return void 0;
+    throw new GitLookupError(`git could not report the repository root: ${(stderr.trim() || errorMessage(err)).split("\n")[0]}`);
+  }
+}
+function contextComesFromControlPlane(repoRoot) {
+  if (pinExists(repoRoot)) return true;
+  const gitCommonDir = resolveGitCommonDir(defaultGitRunner, repoRoot);
+  if (gitCommonDir === void 0) throw new GitLookupError("git could not report this repository's git directory");
+  return readContextManifest(gitCommonDir) !== void 0;
+}
+function mcpReplacementLosesNothing(existing, content) {
+  try {
+    const have = JSON.parse(existing);
+    const next = JSON.parse(content);
+    return Object.entries(have).every(([key, value]) => {
+      if (key !== "mcpServers") return JSON.stringify(next[key]) === JSON.stringify(value);
+      const nextServers = next.mcpServers ?? {};
+      return Object.entries(value ?? {}).every(([name, entry]) => JSON.stringify(nextServers[name]) === JSON.stringify(entry));
+    });
+  } catch {
+    return false;
+  }
+}
+function keepHandWritten(createdSources) {
+  return (output) => {
+    if (output.kind === "copy") return createdSources.has(output.source);
+    if (output.path.endsWith("mcp.json")) return !mcpReplacementLosesNothing(output.existing, output.content);
+    return generatedHeaderSource(output.existing) === null;
+  };
+}
+function runAgentSetup(opts) {
+  let repoRoot;
+  try {
+    repoRoot = gitTopLevel(opts.cwd);
+    if (repoRoot === void 0) return skipped("not a git repository");
+    if (contextComesFromControlPlane(repoRoot)) {
+      return skipped("this repository's context comes from a control plane and arrives at session start");
+    }
+  } catch (err) {
+    return failed(errorMessage(err), /* @__PURE__ */ new Set(), []);
+  }
+  const written = /* @__PURE__ */ new Set();
+  const kept = [];
+  const problems = [];
+  const keptOutputs = /* @__PURE__ */ new Set();
+  const createdSources = new Set(
+    [...loadTemplateFiles(), ...loadMaintainedFiles()].map((f) => f.path).filter((p) => !existsSync(join(repoRoot, p)))
+  );
+  const keep = keepHandWritten(createdSources);
+  try {
+    const pack = installStarterPack({ repoRoot });
+    for (const file of loadTemplateFiles().filter((f) => pack.copied.includes(f.skill))) written.add(file.path);
+    for (const path of pack.maintained) written.add(path);
+    for (const skill of pack.kept) kept.push(`${skillDir(skill)}/`);
+    if (pack.policy === "written") written.add(POLICY_PATH);
+    else kept.push(POLICY_PATH);
+    if (existsSync(join(repoRoot, CONFIG_PATH))) {
+      kept.push(CONFIG_PATH);
+    } else {
+      mkdirSync(dirname(join(repoRoot, CONFIG_PATH)), { recursive: true });
+      writeFileSync(join(repoRoot, CONFIG_PATH), DEFAULT_CONFIG);
+      written.add(CONFIG_PATH);
+    }
+  } catch (err) {
+    return failed(`could not install the skills: ${errorMessage(err)}`, written, kept);
+  }
+  try {
+    const mcp = addStdioMcpEntryIfAbsent(repoRoot);
+    if (mcp.added) written.add(mcp.path);
+    else kept.push(`${mcp.path} (already has an outerlayer server)`);
+  } catch (err) {
+    problems.push(errorMessage(err));
+  }
+  let pending;
+  try {
+    const check = runEmit({ cwd: repoRoot, check: true, quiet: true, keep });
+    pending = check.drift ?? [];
+    const emitted = runEmit({ cwd: repoRoot, quiet: true, keep });
+    for (const path of emitted.kept) keptOutputs.add(path);
+    if (emitted.exitCode !== 0) {
+      const detail = emitted.errors.map((e) => `${e.path}: ${e.message}`).join("; ");
+      problems.push(`context emit failed: ${detail}`);
+    } else {
+      for (const d of pending) if (d.kind !== "orphaned") written.add(d.path);
+    }
+  } catch (err) {
+    problems.push(`context emit failed: ${errorMessage(err)}`);
+  }
+  for (const path of [...keptOutputs].sort()) kept.push(`${path} (written by hand, not replaced)`);
+  const keptPaths = [...keptOutputs].sort();
+  if (problems.length > 0) {
+    for (const path of writtenBeforeFailure(repoRoot, pending, keep)) written.add(path);
+    return failed(problems.join("; "), written, kept, keptPaths);
+  }
+  const paths = [...written].sort();
+  return {
+    outcome: "done",
+    reason: paths.length === 0 ? "already set up" : `${paths.length} files written`,
+    text: renderDone(paths, kept, keptOutputs.has(MCP_OUTPUT_PATH)),
+    paths,
+    kept: keptPaths
+  };
+}
+function writtenBeforeFailure(repoRoot, pending, keep) {
+  if (pending === void 0 || pending.length === 0) return [];
+  try {
+    const now = new Set((runEmit({ cwd: repoRoot, check: true, quiet: true, keep }).drift ?? []).map((d) => d.path));
+    return pending.filter((d) => d.kind !== "orphaned" && !now.has(d.path)).map((d) => d.path);
+  } catch {
+    return [];
+  }
+}
+function failed(reason, written, kept, keptPaths = []) {
+  const paths = [...written].sort();
+  return {
+    outcome: "failed",
+    reason,
+    text: `${C.red}\u2717${C.reset} Agent setup: ${reason}
+${paths.length > 0 ? renderPaths(paths, kept) : ""}`,
+    paths,
+    kept: keptPaths
+  };
+}
+function renderPaths(paths, kept) {
+  const lines = [];
+  if (paths.length > 0) {
+    lines.push("  Written, uncommitted:");
+    for (const p of paths) lines.push(`    ${p}`);
+  }
+  if (kept.length > 0) {
+    lines.push("  Kept as they were:");
+    for (const p of kept) lines.push(`    ${C.dim}${p}${C.reset}`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+function renderDone(paths, kept, mcpKept) {
+  const mcpNote = mcpKept ? `  ${C.yellow}!${C.reset} The outerlayer entry was not added to .mcp.json, so its MCP server is not set up. Add it to .mcp.json by hand, or move the servers you wrote into .outerlayer/mcp.json and run \`outerlayer context emit\`.
+` : "";
+  const what = mcpKept ? "the OuterLayer skills" : "the OuterLayer skills and MCP server";
+  if (paths.length === 0) {
+    return `${C.green}\u2713${C.reset} Agent setup: already in place, nothing changed
+${renderPaths(paths, kept)}${mcpNote}`;
+  }
+  return `${C.green}\u2713${C.reset} Agent setup: Claude Code has ${what}
+` + renderPaths(paths, kept) + mcpNote + `  ${C.dim}\`context emit\` compiled every source under .outerlayer/ for the targets in ${CONFIG_PATH}, not only the skills.${C.reset}
+`;
+}
+
+export { runAgentSetup };

package/dist/build-TZUUTRGH.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+export { buildRepositoryImage } from './chunk-ZNA27WEV.js';
+import './chunk-N5FOE5PS.js';
+export { RecipeError } from './chunk-QOZKPLVJ.js';
+import './chunk-ZM2IMMYN.js';
+import './chunk-Z5GEFMRW.js';
+
+createRequire(import.meta.url);

package/dist/build-info.json

@@ -1 +1 @@
-{"id":"2026-09-25T19:18:18.529Z+059710d","root":"/home/runner/_work/outerlayer/outerlayer","pkg":"outerlayer"}
+{"id":"2026-10-03T04:29:29.613Z+d16bdd8","root":"/home/runner/_work/outerlayer/outerlayer","pkg":"outerlayer"}

package/dist/check-7MFH6HNC.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { probeCredentials } from './chunk-QY22NZUW.js';
+import './chunk-DM3VFDS3.js';
+import './chunk-QDQEUVUF.js';
+import './chunk-ABIWDUMS.js';
+import './chunk-YYYXRJUW.js';
+import './chunk-CBPPJSAR.js';
+import { placeholderQueues, placeholderProblem, needsClaudeCredential, claudeCredentialCheck, claimPermissionProblem } from './chunk-RFUPN6KX.js';
+import './chunk-LYCDNMOH.js';
+import './chunk-TBT347UY.js';
+import './chunk-YFHIIH4B.js';
+import './chunk-3TFPDVTI.js';
+import './chunk-HZRNMGLF.js';
+import './chunk-ZNA27WEV.js';
+import './chunk-N5FOE5PS.js';
+import './chunk-OGFGZQA3.js';
+import './chunk-774HEQL6.js';
+import './chunk-QOZKPLVJ.js';
+import './chunk-W4SQCOZU.js';
+import './chunk-B2G7JHHB.js';
+import './chunk-W5FVUZXV.js';
+import './chunk-BFESLKPP.js';
+import './chunk-WFJ65NUD.js';
+import './chunk-4C4THABW.js';
+import { loadRunnerConfig, RunnerConfigError, checkHooks } from './chunk-5Y3QQRUH.js';
+import './chunk-F6GFZXZ3.js';
+import './chunk-AUFG23AA.js';
+import './chunk-WZBHBH3J.js';
+import './chunk-XDDW4FRS.js';
+import './chunk-WIOZAJ2W.js';
+import './chunk-WO2BXCTQ.js';
+import './chunk-EMY4I27X.js';
+import './chunk-ZJSNLVCE.js';
+import './chunk-BCLJSQCV.js';
+import './chunk-BOLTI6LR.js';
+import './chunk-EABW6AJQ.js';
+import './chunk-RA3O54FC.js';
+import './chunk-M5POMKKW.js';
+import './chunk-ZM2IMMYN.js';
+import './chunk-XCCLFVXM.js';
+import './chunk-BJ3KTMDH.js';
+import './chunk-VNVZDWO3.js';
+import './chunk-Z5GEFMRW.js';
+
+createRequire(import.meta.url);
+
+// src/runner/check.ts
+async function runRunnerCheck(configPath, deps = {}) {
+  let config;
+  try {
+    config = loadRunnerConfig(configPath);
+  } catch (err) {
+    return { ok: false, check: "config", message: err instanceof RunnerConfigError ? err.message : String(err) };
+  }
+  const hookProblem = checkHooks(config, deps.env ?? process.env);
+  if (hookProblem) return { ok: false, check: "hooks", message: `${configPath}: ${hookProblem}` };
+  const placeholders = placeholderQueues(config);
+  if (placeholders.length > 0) {
+    return { ok: false, check: "placeholders", message: `${configPath}: ${placeholderProblem(placeholders)}` };
+  }
+  if (needsClaudeCredential(config.hooks)) {
+    const credential = claudeCredentialCheck(deps.env ?? process.env);
+    if (credential.status === "fail") {
+      return { ok: false, check: "claude credential", message: `${credential.detail}. ${credential.fix}` };
+    }
+  }
+  const probe = await probeCredentials(config, deps.fetchImpl);
+  if (!probe.ok && probe.fatal) return { ok: false, check: "credentials", message: probe.reason };
+  const claimProblem = await claimPermissionProblem(config, deps.fetchImpl);
+  if (claimProblem.status === "lacks") {
+    return { ok: false, check: "claim permission", message: `${configPath}: ${claimProblem.problem}` };
+  }
+  const unverifiedReason = probe.ok ? claimProblem.reason : probe.reason;
+  const lines = [
+    `config              ${configPath}`,
+    `host                ${config.host}`,
+    `queues              ${config.queues.join(", ")}`,
+    `concurrency         ${config.concurrency}`,
+    `poll                ${config.pollSeconds}s`,
+    `time limit          ${config.timeLimitMinutes}m`,
+    `idle limit          ${config.idleLimitMinutes}m`,
+    `auto update         ${config.autoUpdate ? "on" : "off"}`,
+    ...config.queues.map((queue) => `command ${queue.padEnd(11)} ${config.commands[queue] ?? "(none)"}`),
+    `hook provision      ${config.hooks.provision}`,
+    `hook cleanup        ${config.hooks.cleanup}`,
+    `hook report         ${config.hooks.report ?? "(none)"}`,
+    `repos include       ${config.repos?.include?.join(", ") ?? "(all)"}`,
+    `repos exclude       ${config.repos?.exclude?.join(", ") ?? "(none)"}`
+  ];
+  return { ok: true, lines, unverifiedReason, summary: `${config.url} \xB7 app ${config.appId}` };
+}
+
+export { runRunnerCheck };

package/dist/chunk-3TFPDVTI.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { MIN_ENGINE_MAJOR } from './chunk-HZRNMGLF.js';
+import { firecrackerArch, MICROVM_ARCHES, guestAssetsPinned } from './chunk-ZNA27WEV.js';
+import { spawnSync } from 'child_process';
+import { existsSync, accessSync, constants, statSync, readFileSync } from 'fs';
+
+createRequire(import.meta.url);
+function groupName(gid) {
+  try {
+    for (const line of readFileSync("/etc/group", "utf8").split("\n")) {
+      const [name, , id] = line.split(":");
+      if (name !== void 0 && Number(id) === gid) return name;
+    }
+  } catch {
+  }
+  return String(gid);
+}
+function detectKvm(device) {
+  if (!existsSync(device)) return { state: "absent" };
+  try {
+    accessSync(device, constants.R_OK | constants.W_OK);
+    return { state: "usable" };
+  } catch {
+    return { state: "no-permission", group: groupName(statSync(device).gid) };
+  }
+}
+function readProcVersion() {
+  try {
+    return readFileSync("/proc/version", "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function docker(args) {
+  const result = spawnSync("docker", args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 15e3 });
+  const out = result.status === 0 ? result.stdout.trim() : "";
+  return out === "" ? void 0 : out;
+}
+function dockerFailure() {
+  const result = spawnSync("docker", ["version", "--format", "{{.Server.Version}}"], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 15e3 });
+  if (result.error?.code === "ENOENT") return void 0;
+  return /permission denied/i.test(result.stderr ?? "") ? "permission" : "daemon";
+}
+function platformOf(probes) {
+  const platform = probes.platform ?? process.platform;
+  if (platform === "win32") return "windows";
+  if (platform === "darwin") return "darwin";
+  if (platform !== "linux") return "other";
+  return /microsoft/i.test((probes.procVersion ?? readProcVersion)() ?? "") ? "wsl2" : "linux";
+}
+function detectMachine(probes = {}) {
+  const platform = platformOf(probes);
+  const kvm = (probes.kvm ?? (() => detectKvm(probes.kvmDevice ?? "/dev/kvm")))();
+  const arch = firecrackerArch(probes.nodeArch ?? process.arch);
+  const version = (probes.dockerVersion ?? (() => docker(["version", "--format", "{{.Server.Version}}"])))();
+  if (version === void 0) {
+    const failure = (probes.dockerFailure ?? (probes.dockerVersion === void 0 ? dockerFailure : () => void 0))();
+    return { platform, docker: failure === void 0 ? { kind: "none" } : { kind: "unreachable", reason: failure }, kvm, arch };
+  }
+  const system = (probes.dockerOperatingSystem ?? (() => docker(["info", "--format", "{{.OperatingSystem}}"])))() ?? "";
+  return { platform, docker: { kind: /docker desktop/i.test(system) ? "desktop" : "engine", version }, kvm, arch };
+}
+function supportsContainerBuilds(machine) {
+  if (machine.platform !== "linux" && machine.platform !== "wsl2") return false;
+  return machine.docker.kind === "engine" && Number.parseInt(machine.docker.version ?? "", 10) >= MIN_ENGINE_MAJOR;
+}
+function supportsMicroVmBuilds(machine) {
+  return machine.platform === "linux" && machine.kvm?.state === "usable" && supportsContainerBuilds(machine) && microVmAssetsPinned(machine);
+}
+function microVmArchSupported(machine) {
+  return MICROVM_ARCHES.includes(machine.arch ?? "");
+}
+function microVmAssetsPinned(machine) {
+  return microVmArchSupported(machine) && guestAssetsPinned(machine.arch);
+}
+function reachDockerStep(machine) {
+  if (machine.docker.kind !== "unreachable") return void 0;
+  return machine.docker.reason === "permission" ? "give this user access to Docker Engine's socket (add it to the docker group, then log in again)" : "start Docker Engine's daemon (for example, sudo systemctl start docker)";
+}
+function describeMachineDocker(machine) {
+  const { kind, version, reason } = machine.docker;
+  const where = machine.platform === "windows" ? "Windows" : machine.platform === "darwin" ? "macOS" : machine.platform === "wsl2" ? "WSL2" : "Linux";
+  if (kind === "desktop") return `Docker Desktop ${version ?? ""} on ${where}, which cannot pass a Unix socket into a container`.replace("  ", " ");
+  if (kind === "none") return `no Docker on ${where}`;
+  if (kind === "unreachable") {
+    const problem = reason === "permission" ? "this user has no permission on its socket" : "its daemon is not running";
+    return `a docker command on ${where} that cannot reach Docker Engine (${problem})`;
+  }
+  if (machine.platform !== "linux" && machine.platform !== "wsl2") return `Docker Engine ${version ?? ""} on ${where}, which cannot isolate a build`.replace("  ", " ");
+  return `Docker Engine ${version ?? "of no known version"}, older than the ${MIN_ENGINE_MAJOR} that container builds need`;
+}
+
+export { describeMachineDocker, detectMachine, microVmArchSupported, microVmAssetsPinned, reachDockerStep, supportsContainerBuilds, supportsMicroVmBuilds };