@outerlayer/cli 0.20.0 → 0.22.1

package/dist/chunk-ZNPE7FW5.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { rewriteControlPlanePaths, rewriteAgentsFilePaths, SUPPORTED_CONTROL_PLANE_LAYOUT, rewriteHookCommand } from './chunk-HCVLP7XA.js';
+import { MAINTAINED_SKILLS } from './chunk-5OCIHFGE.js';
+import { existsSync, mkdirSync, copyFileSync, lstatSync, readdirSync, writeFileSync, readFileSync } from 'fs';
+import { join, dirname } from 'path';
+
+createRequire(import.meta.url);
+function deliverySection(dir) {
+  return `This repository's control plane is not in the checkout. Its files are in \`${dir}\`. When the instructions name a file under \`.agents/\` that this directory holds, or a path under \`.outerlayer/\` or \`.claude/\`, read it under \`${dir}\`.`;
+}
+function isFile(path) {
+  try {
+    return lstatSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+function filesUnder(dir, base = dir) {
+  if (!existsSync(dir) || !lstatSync(dir).isDirectory()) return [];
+  const out = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const abs = join(dir, entry.name);
+    if (entry.isDirectory()) out.push(...filesUnder(abs, base));
+    else if (entry.isFile()) out.push(abs.slice(base.length + 1));
+  }
+  return out.sort();
+}
+function readText(path) {
+  if (!isFile(path)) return void 0;
+  const content = readFileSync(path);
+  return content.includes(0) ? void 0 : content.toString("utf8");
+}
+function deliveredSettings(raw, dir) {
+  if (raw === void 0) return "{}\n";
+  const rewrite = (value) => {
+    if (typeof value === "string") return rewriteHookCommand(value, dir);
+    if (Array.isArray(value)) return value.map(rewrite);
+    if (typeof value === "object" && value !== null) return Object.fromEntries(Object.entries(value).map(([key, inner]) => [key, rewrite(inner)]));
+    return value;
+  };
+  try {
+    return `${JSON.stringify(rewrite(JSON.parse(raw)), null, 2)}
+`;
+  } catch {
+    return rewriteHookCommand(raw, dir);
+  }
+}
+function composeDelivery(input) {
+  const { tree, dir } = input;
+  const added = [];
+  const put = (rel, content) => {
+    mkdirSync(dirname(join(tree, rel)), { recursive: true });
+    writeFileSync(join(tree, rel), content);
+    added.push(rel);
+  };
+  for (const skill of MAINTAINED_SKILLS) {
+    for (const rel of filesUnder(join(tree, ".outerlayer/skills", skill))) {
+      const target = `.claude/skills/${skill}/${rel}`;
+      if (existsSync(join(tree, target))) continue;
+      mkdirSync(dirname(join(tree, target)), { recursive: true });
+      copyFileSync(join(tree, ".outerlayer/skills", skill, rel), join(tree, target));
+      added.push(target);
+    }
+  }
+  const agentSkills = join(tree, ".agents/skills");
+  if (existsSync(agentSkills) && lstatSync(agentSkills).isDirectory()) {
+    for (const entry of readdirSync(agentSkills, { withFileTypes: true })) {
+      if (!entry.isDirectory() || existsSync(join(tree, ".claude/skills", entry.name))) continue;
+      for (const rel of filesUnder(join(agentSkills, entry.name))) {
+        const target = `.claude/skills/${entry.name}/${rel}`;
+        mkdirSync(dirname(join(tree, target)), { recursive: true });
+        copyFileSync(join(agentSkills, entry.name, rel), join(tree, target));
+        added.push(target);
+      }
+    }
+  }
+  for (const rel of [...filesUnder(join(tree, ".claude/skills"), tree), ...filesUnder(join(tree, ".claude/agents"), tree)]) {
+    const text = readText(join(tree, rel));
+    if (text === void 0) continue;
+    const rewritten = rewriteControlPlanePaths(text, dir);
+    if (rewritten !== text) writeFileSync(join(tree, rel), rewritten);
+  }
+  const agents = readText(join(tree, "AGENTS.md"));
+  const instructions = agents === void 0 ? void 0 : rewriteAgentsFilePaths(rewriteControlPlanePaths(agents, dir), dir, (path) => isFile(join(tree, path)));
+  put("CLAUDE.md", instructions === void 0 ? `${deliverySection(dir)}
+` : `${deliverySection(dir)}
+
+${instructions}`);
+  put("settings.json", deliveredSettings(readText(join(tree, ".claude/settings.json")), dir));
+  return added;
+}
+function sharedSkillNames(tree) {
+  const dir = join(tree, ".claude/skills");
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+}
+function skillConflictMessage(input) {
+  return `${input.folder}/${input.skill} in ${input.repository} has the same name as the shared skill ${input.skill} from ${input.controlPlane}`;
+}
+var UNPARSABLE_CONFIG = "unparsable";
+function isNewerLayout(declared) {
+  return /^[1-9][0-9]*$/.test(declared) && Number(declared) > SUPPORTED_CONTROL_PLANE_LAYOUT;
+}
+function layoutProblem(repository, declared, upgrade) {
+  if (declared === UNPARSABLE_CONFIG) {
+    return { what: `the control plane ${repository} has an .outerlayer/config.json that is not valid JSON`, advice: "fix the file" };
+  }
+  return {
+    what: `the control plane ${repository} declares layout ${declared}`,
+    advice: isNewerLayout(declared) ? `${upgrade} to a version that reads layout ${declared}` : `set "layout" in .outerlayer/config.json to 1 or ${SUPPORTED_CONTROL_PLANE_LAYOUT}`
+  };
+}
+function unsupportedLayout(root) {
+  const text = readText(join(root, ".outerlayer/config.json"));
+  if (text === void 0) return void 0;
+  let declared;
+  try {
+    declared = JSON.parse(text)?.layout;
+  } catch {
+    return UNPARSABLE_CONFIG;
+  }
+  if (declared === void 0) return void 0;
+  if (typeof declared === "number" && Number.isInteger(declared) && declared >= 1 && declared <= SUPPORTED_CONTROL_PLANE_LAYOUT) return void 0;
+  return JSON.stringify(declared);
+}
+function layoutRefusalMessage(repository, declared) {
+  const { what, advice } = layoutProblem(repository, declared, "upgrade the CLI");
+  return `outerlayer claude: ${what}, and this CLI reads layouts 1 and ${SUPPORTED_CONTROL_PLANE_LAYOUT}; ${advice}
+`;
+}
+function layoutRefusalReason(repository, declared) {
+  const { what, advice } = layoutProblem(repository, declared, "upgrade the CLI on the runner host");
+  return `context_layout_unsupported: ${what}, and this runner's CLI reads layouts 1 and ${SUPPORTED_CONTROL_PLANE_LAYOUT}; ${advice}`;
+}
+
+export { composeDelivery, layoutRefusalMessage, layoutRefusalReason, sharedSkillNames, skillConflictMessage, unsupportedLayout };

package/dist/{chunk-PIZRPNKR.js → chunk-ZPSLJFGL.js}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { hasStoredCredential, AGENT_COMMANDS, storeClaudeCredential, credentialFromStdin, isAgentName } from './chunk-7YP7T6GV.js';
-import { detectMachine, supportsContainerBuilds, reachDockerStep, describeMachineDocker, supportsMicroVmBuilds } from './chunk-LW7G5TJB.js';
-import { MIN_ENGINE_MAJOR } from './chunk-3ZR7Y23Y.js';
-import { runnerCredentialProblem } from './chunk-P53VEAOF.js';
-import { runnerDir, RUNNER_DIR_MODE, RUNNER_FILE_MODE } from './chunk-N2PXGQRL.js';
+import { hasStoredCredential, AGENT_COMMANDS, storeClaudeCredential, credentialFromStdin, isAgentName } from './chunk-4AVDD7VX.js';
+import { detectMachine, supportsContainerBuilds, reachDockerStep, describeMachineDocker, supportsMicroVmBuilds } from './chunk-FRNYCJ4W.js';
+import { MIN_ENGINE_MAJOR } from './chunk-5NJIWKD4.js';
+import { runnerCredentialProblem } from './chunk-V5CG75NX.js';
+import { runnerDir, RUNNER_DIR_MODE, RUNNER_FILE_MODE } from './chunk-IHNQWF6F.js';
 import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'fs';
 import { dirname } from 'path';
 

package/dist/claude-launcher-TBWV3YL3.js

@@ -0,0 +1,267 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { sharedSkillNames } from './chunk-ZNPE7FW5.js';
+import { GOVERNANCE_VARIABLE, versionAtLeast, MINIMUM_CLAUDE_VERSION, SHIM_SCRIPT, CONTROL_PLANE_DIR_VARIABLE } from './chunk-HCVLP7XA.js';
+export { MINIMUM_CLAUDE_VERSION } from './chunk-HCVLP7XA.js';
+import { findGitDirs } from './chunk-BJ3KTMDH.js';
+import './chunk-5OCIHFGE.js';
+import './chunk-WFSUUUAN.js';
+import './chunk-7VUK5RFS.js';
+import { homeFromEnv } from './chunk-VNVZDWO3.js';
+import './chunk-RA3O54FC.js';
+import './chunk-Z5GEFMRW.js';
+import { spawnSync, execFileSync, spawn } from 'child_process';
+import { existsSync, accessSync, constants, statSync, readFileSync, readdirSync, lstatSync, rmSync, mkdirSync, realpathSync, symlinkSync, renameSync, readlinkSync, writeFileSync } from 'fs';
+import { join, delimiter, isAbsolute, resolve } from 'path';
+import { createHash, randomBytes } from 'crypto';
+
+createRequire(import.meta.url);
+function ownSkillsRoot(home) {
+  return join(home, ".outerlayer", "context", "own");
+}
+function folderNames(dir) {
+  try {
+    return readdirSync(dir).filter((name) => {
+      try {
+        return statSync(join(dir, name)).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+function wantedLinks(repoRoot, shared) {
+  const provided = new Set(folderNames(join(repoRoot, ".claude", "skills")));
+  const wanted = /* @__PURE__ */ new Map();
+  for (const name of folderNames(join(repoRoot, ".agents", "skills")).sort()) {
+    if (provided.has(name) || shared.has(name)) continue;
+    wanted.set(name, join(repoRoot, ".agents", "skills", name));
+  }
+  return wanted;
+}
+function holdsLinks(dir, wanted) {
+  const skills = join(dir, ".claude", "skills");
+  let names;
+  try {
+    names = readdirSync(skills);
+  } catch {
+    return false;
+  }
+  if (names.length !== wanted.size) return false;
+  return names.every((name) => {
+    try {
+      return readlinkSync(join(skills, name)) === wanted.get(name);
+    } catch {
+      return false;
+    }
+  });
+}
+function removeQuietly(path) {
+  rmSync(path, { recursive: true, force: true });
+}
+var REPLACE_ATTEMPTS = 3;
+function ensureOwnSkillsDir(input) {
+  const wanted = wantedLinks(input.repoRoot, new Set(input.shared));
+  if (wanted.size === 0) return void 0;
+  const root = ownSkillsRoot(input.home);
+  mkdirSync(root, { recursive: true });
+  const checkout = realpathSync(input.repoRoot);
+  const key = createHash("sha256").update(checkout).digest("hex").slice(0, 16);
+  const final = join(root, key);
+  const record = join(root, `${key}.json`);
+  const writeRecord = () => {
+    const temporary2 = join(root, `.tmp-${randomBytes(6).toString("hex")}.json`);
+    writeFileSync(temporary2, `${JSON.stringify({ checkout })}
+`);
+    renameSync(temporary2, record);
+  };
+  if (holdsLinks(final, wanted)) {
+    if (!existsSync(record)) writeRecord();
+    return final;
+  }
+  const temporary = join(root, `.tmp-${randomBytes(6).toString("hex")}`);
+  mkdirSync(join(temporary, ".claude", "skills"), { recursive: true });
+  for (const [name, target] of wanted) symlinkSync(target, join(temporary, ".claude", "skills", name));
+  try {
+    for (let attempt = 0; attempt < REPLACE_ATTEMPTS; attempt += 1) {
+      try {
+        renameSync(temporary, final);
+        writeRecord();
+        return final;
+      } catch {
+        if (holdsLinks(final, wanted)) {
+          writeRecord();
+          return final;
+        }
+        if (attempt === REPLACE_ATTEMPTS - 1) break;
+        const old = join(root, `.old-${randomBytes(6).toString("hex")}`);
+        try {
+          renameSync(final, old);
+          removeQuietly(old);
+        } catch {
+        }
+      }
+    }
+    return void 0;
+  } finally {
+    removeQuietly(temporary);
+  }
+}
+var LEFTOVER_AGE_MS = 10 * 6e4;
+function removeStaleOwnSkillsDirs(home, now = Date.now()) {
+  const root = ownSkillsRoot(home);
+  let entries;
+  try {
+    entries = readdirSync(root);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const path = join(root, entry);
+    if (entry.startsWith(".")) {
+      try {
+        if (now - lstatSync(path).mtimeMs > LEFTOVER_AGE_MS) removeQuietly(path);
+      } catch {
+      }
+      continue;
+    }
+    if (!entry.endsWith(".json")) continue;
+    let checkout;
+    try {
+      checkout = JSON.parse(readFileSync(path, "utf8")).checkout;
+    } catch {
+      continue;
+    }
+    if (typeof checkout !== "string" || existsSync(checkout)) continue;
+    removeQuietly(join(root, entry.slice(0, -".json".length)));
+    removeQuietly(path);
+  }
+}
+
+// src/claude-launcher.ts
+function readDeliveryRecord(cwd) {
+  let common;
+  try {
+    common = execFileSync("git", ["rev-parse", "--git-common-dir"], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5e3 }).trim();
+  } catch {
+    return { kind: "none" };
+  }
+  const path = join(isAbsolute(common) ? common : resolve(cwd, common), "outerlayer", "delivery.json");
+  if (!existsSync(path)) return { kind: "none" };
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (typeof parsed.dir === "string" && isAbsolute(parsed.dir) && typeof parsed.repository === "string" && typeof parsed.sha === "string") {
+      return { kind: "found", record: { repository: parsed.repository, sha: parsed.sha, dir: parsed.dir, launcher: parsed.launcher === true } };
+    }
+  } catch {
+  }
+  return { kind: "invalid", path };
+}
+function findClaude(path) {
+  for (const entry of (path ?? "").split(delimiter)) {
+    if (entry === "") continue;
+    const candidate = join(entry, "claude");
+    try {
+      accessSync(candidate, constants.X_OK);
+      if (statSync(candidate).size === Buffer.byteLength(SHIM_SCRIPT) && readFileSync(candidate, "utf8") === SHIM_SCRIPT) continue;
+    } catch {
+      continue;
+    }
+    return candidate;
+  }
+  return void 0;
+}
+var SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+var SIGNAL_NUMBERS = { SIGHUP: 1, SIGINT: 2, SIGTERM: 15 };
+function run(program, argv, env, cwd, stderr) {
+  return new Promise((done) => {
+    const child = spawn(program, argv, { cwd, env, stdio: "inherit" });
+    const forward = (signal) => () => {
+      child.kill(signal);
+    };
+    const handlers = SIGNALS.map((signal) => [signal, forward(signal)]);
+    for (const [signal, handler] of handlers) process.on(signal, handler);
+    const finish = (code) => {
+      for (const [signal, handler] of handlers) process.off(signal, handler);
+      done(code);
+    };
+    child.on("error", (err) => {
+      stderr(`outerlayer claude: could not start ${program}: ${err.message}
+`);
+      finish(127);
+    });
+    child.on("exit", (code, signal) => finish(code ?? 128 + (signal === null ? 0 : SIGNAL_NUMBERS[signal] ?? 0)));
+  });
+}
+function ownSkillsDirFor(cwd, home, shared, stderr) {
+  const root = findGitDirs(cwd)?.repoRoot;
+  if (root === void 0) return void 0;
+  try {
+    return ensureOwnSkillsDir({ home, repoRoot: root, shared });
+  } catch (err) {
+    stderr(`outerlayer claude: the checkout's .agents/skills/ skills are not attached: ${err instanceof Error ? err.message : String(err)}
+`);
+    return void 0;
+  }
+}
+async function runClaudeLauncher(args, deps = {}) {
+  const cwd = deps.cwd ?? process.cwd();
+  const env = deps.env ?? process.env;
+  const stderr = deps.stderr ?? ((text) => void process.stderr.write(text));
+  const claude = findClaude(env.PATH);
+  if (claude === void 0) {
+    stderr("outerlayer claude: no claude program found on PATH\n");
+    return 127;
+  }
+  const home = homeFromEnv(env);
+  try {
+    removeStaleOwnSkillsDirs(home);
+  } catch {
+  }
+  const found = readDeliveryRecord(cwd);
+  const build = found.kind === "found" && found.record.launcher !== true ? found.record : void 0;
+  if (found.kind === "invalid" && env.OUTERLAYER_JOB_DIR !== void 0) {
+    stderr(`outerlayer claude: ${found.path} is not a readable delivery record, so the control plane cannot be attached
+`);
+    return 1;
+  }
+  let dir;
+  if (build !== void 0) {
+    dir = build.dir;
+    if (!existsSync(dir)) {
+      stderr(`outerlayer claude: the control plane of ${build.repository} is not at ${dir}, so it cannot be attached
+`);
+      return 1;
+    }
+  } else {
+    const { resolveLaunchPlane } = await import('./control-plane-launch-OWSNH6YA.js');
+    const plane = env[GOVERNANCE_VARIABLE] === "self" ? { kind: "none" } : await resolveLaunchPlane({ cwd, env, home, fetchImpl: deps.fetchImpl, stderr });
+    if (plane.kind === "none") {
+      const own2 = ownSkillsDirFor(cwd, home, [], stderr);
+      return run(claude, own2 === void 0 ? args : ["--add-dir", own2, ...args], env, cwd, stderr);
+    }
+    if (plane.kind === "refused") {
+      stderr(plane.message);
+      return 1;
+    }
+    dir = plane.dir;
+  }
+  const reported = spawnSync(claude, ["--version"], { env, encoding: "utf8", timeout: 15e3, stdio: ["ignore", "pipe", "ignore"] }).stdout ?? "";
+  if (/\d+\.\d+\.\d+/.test(reported) && !versionAtLeast(reported)) {
+    stderr(`outerlayer claude: Claude Code ${reported.trim().split(/\s+/)[0]} is older than ${MINIMUM_CLAUDE_VERSION}, the oldest version known to load a control plane's instructions for subagents; the minimum version is ${MINIMUM_CLAUDE_VERSION}
+`);
+    return 1;
+  }
+  const own = ownSkillsDirFor(cwd, home, sharedSkillNames(dir), stderr);
+  return run(
+    claude,
+    ["--add-dir", dir, ...own === void 0 ? [] : ["--add-dir", own], "--settings", join(dir, "settings.json"), ...args],
+    { ...env, CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD: "1", [CONTROL_PLANE_DIR_VARIABLE]: dir },
+    cwd,
+    stderr
+  );
+}
+
+export { runClaudeLauncher };