@outerlayer/cli 0.18.0 → 0.19.1

package/dist/{chunk-LXAY4A2G.js → chunk-YQR6E6OV.js}

@@ -1,34 +1,9 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { CONTEXT_PIN_SCHEMA_VERSION, CONTEXT_PIN_FILENAME } from './chunk-X5N6KC6V.js';
-import { readFileSync, existsSync, writeFileSync, mkdirSync, utimesSync, unlinkSync } from 'fs';
-import { join, dirname } from 'path';
+import { unlinkSync, readFileSync, mkdirSync, writeFileSync, existsSync } from 'fs';
+import { isAbsolute, join, dirname } from 'path';
 
 createRequire(import.meta.url);
-function pinPath(workpieceRoot) {
-  return join(workpieceRoot, CONTEXT_PIN_FILENAME);
-}
-function readPin(workpieceRoot) {
-  try {
-    const parsed = JSON.parse(readFileSync(pinPath(workpieceRoot), "utf8"));
-    if (typeof parsed === "object" && parsed !== null && typeof parsed.sha === "string" && typeof parsed.schemaVersion === "number") {
-      return parsed;
-    }
-    return void 0;
-  } catch {
-    return void 0;
-  }
-}
-function pinExists(workpieceRoot) {
-  return existsSync(pinPath(workpieceRoot));
-}
-function writePinIfChanged(workpieceRoot, sha) {
-  const existing = readPin(workpieceRoot);
-  if (existing?.sha === sha && existing.schemaVersion === CONTEXT_PIN_SCHEMA_VERSION) return false;
-  const pin = { schemaVersion: CONTEXT_PIN_SCHEMA_VERSION, sha };
-  writeFileSync(pinPath(workpieceRoot), JSON.stringify(pin) + "\n");
-  return true;
-}
 function stateDir(gitCommonDir) {
   return join(gitCommonDir, "outerlayer");
 }
@@ -56,19 +31,9 @@ function readContextManifest(gitCommonDir) {
 function writeContextManifest(gitCommonDir, manifest) {
   writeJson(manifestPath(gitCommonDir), manifest);
 }
-function manifestFilesPresent(workpieceRoot, manifest) {
-  return manifest.files.every((f) => existsSync(join(workpieceRoot, f)));
-}
-function lastCheckPath(gitCommonDir) {
-  return join(stateDir(gitCommonDir), "last-check");
-}
-function touchLastCheck(gitCommonDir, now) {
-  const path = lastCheckPath(gitCommonDir);
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, String(now));
-  const seconds = now / 1e3;
+function removeContextManifest(gitCommonDir) {
   try {
-    utimesSync(path, seconds, seconds);
+    unlinkSync(manifestPath(gitCommonDir));
   } catch {
   }
 }
@@ -107,18 +72,38 @@ function writeSourceCache(gitCommonDir, cache) {
 function isSourceCacheFresh(cache, now) {
   return now - Date.parse(cache.checkedAt) < cache.ttlMs;
 }
-function buildHoldPath(gitCommonDir) {
-  return join(stateDir(gitCommonDir), "build-hold.json");
-}
-function readBuildHold(gitCommonDir) {
-  const parsed = readJson(buildHoldPath(gitCommonDir));
-  if (parsed && typeof parsed.sha === "string" && typeof parsed.repository === "string" && typeof parsed.ref === "string" && typeof parsed.at === "string") {
-    return parsed;
+function deliveryRecordPath(gitCommonDir) {
+  return join(stateDir(gitCommonDir), "delivery.json");
+}
+function readDeliveryRecord(gitCommonDir) {
+  const parsed = readJson(deliveryRecordPath(gitCommonDir));
+  if (typeof parsed?.dir === "string" && isAbsolute(parsed.dir) && typeof parsed.repository === "string" && typeof parsed.sha === "string") {
+    return {
+      ...typeof parsed.schemaVersion === "number" ? { schemaVersion: parsed.schemaVersion } : {},
+      repository: parsed.repository,
+      ...typeof parsed.ref === "string" ? { ref: parsed.ref } : {},
+      sha: parsed.sha,
+      dir: parsed.dir,
+      ...parsed.launcher === true ? { launcher: true } : {}
+    };
   }
   return void 0;
 }
-function writeBuildHold(gitCommonDir, hold) {
-  writeJson(buildHoldPath(gitCommonDir), hold);
+function removeLauncherDeliveryRecord(gitCommonDir) {
+  if (readDeliveryRecord(gitCommonDir)?.launcher !== true) return;
+  try {
+    unlinkSync(deliveryRecordPath(gitCommonDir));
+  } catch {
+  }
+}
+function deliveryRecordExists(gitCommonDir) {
+  return existsSync(deliveryRecordPath(gitCommonDir));
+}
+function writeDeliveryRecord(gitCommonDir, record) {
+  writeJson(deliveryRecordPath(gitCommonDir), record);
+}
+function cloneIsGoverned(gitCommonDir) {
+  return readSourceCache(gitCommonDir)?.status === "governed" || deliveryRecordExists(gitCommonDir);
 }
 
-export { SOURCE_CACHE_TTL_RETRY_MS, SOURCE_CACHE_TTL_SUCCESS_MS, clearDegraded, isSourceCacheFresh, manifestFilesPresent, pinExists, readBuildHold, readContextManifest, readDegraded, readPin, readSourceCache, touchLastCheck, writeBuildHold, writeContextManifest, writeDegraded, writePinIfChanged, writeSourceCache };
+export { SOURCE_CACHE_TTL_RETRY_MS, SOURCE_CACHE_TTL_SUCCESS_MS, clearDegraded, cloneIsGoverned, isSourceCacheFresh, readContextManifest, readDegraded, readDeliveryRecord, readSourceCache, removeContextManifest, removeLauncherDeliveryRecord, writeContextManifest, writeDegraded, writeDeliveryRecord, writeSourceCache };

package/dist/chunk-Z7K3L4FC.js

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { readContextManifest, removeContextManifest } from './chunk-YQR6E6OV.js';
+import { removePreCommitGuardHook } from './chunk-TUSYOL2O.js';
+import { CONTEXT_PIN_FILENAME } from './chunk-WFSUUUAN.js';
+import { execFileSync } from 'child_process';
+import { existsSync, unlinkSync, lstatSync, readdirSync, rmdirSync, readFileSync, mkdirSync, writeFileSync } from 'fs';
+import { join, dirname, isAbsolute } from 'path';
+
+createRequire(import.meta.url);
+var CONTEXT_EXCLUDE_MARKER = "outerlayer context materialization";
+var BEGIN_PREFIX = `# BEGIN ${CONTEXT_EXCLUDE_MARKER}`;
+var END = `# END ${CONTEXT_EXCLUDE_MARKER}`;
+function excludeFilePath(gitCommonDir) {
+  return join(gitCommonDir, "info", "exclude");
+}
+function readLines(path) {
+  if (!existsSync(path)) return [];
+  const content = readFileSync(path, "utf8");
+  if (content === "") return [];
+  const lines = content.split("\n");
+  if (lines[lines.length - 1] === "") lines.pop();
+  return lines;
+}
+function writeLines(path, lines) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, lines.length ? lines.join("\n") + "\n" : "");
+}
+function findWellFormedBlock(lines) {
+  let i = 0;
+  while (i < lines.length) {
+    if (!lines[i].startsWith(BEGIN_PREFIX)) {
+      i++;
+      continue;
+    }
+    const beginIdx = i;
+    let endIdx = -1;
+    let j = beginIdx + 1;
+    for (; j < lines.length; j++) {
+      if (lines[j] === END) {
+        endIdx = j;
+        break;
+      }
+      if (lines[j].startsWith(BEGIN_PREFIX)) break;
+    }
+    if (endIdx !== -1) return { beginIdx, endIdx };
+    i = j;
+  }
+  return void 0;
+}
+function removeContextExcludes(gitCommonDir) {
+  const path = excludeFilePath(gitCommonDir);
+  const lines = readLines(path);
+  const block = findWellFormedBlock(lines);
+  if (block === void 0) return { changed: false };
+  writeLines(path, [...lines.slice(0, block.beginIdx), ...lines.slice(block.endIdx + 1)]);
+  return { changed: true };
+}
+function contextExcludesPresent(gitCommonDir) {
+  return findWellFormedBlock(readLines(excludeFilePath(gitCommonDir))) !== void 0;
+}
+
+// src/context-cleanup.ts
+function hasEarlierCopies(gitCommonDir) {
+  return readContextManifest(gitCommonDir) !== void 0 || contextExcludesPresent(gitCommonDir);
+}
+function isCopiedPath(rel) {
+  if (isAbsolute(rel) || rel.split("/").includes("..")) return false;
+  return rel === "AGENTS.md" || rel.startsWith(".claude/") || rel.startsWith(".outerlayer/");
+}
+function hasSymlinkComponent(root, rel) {
+  let current = root;
+  for (const segment of rel.split("/")) {
+    current = join(current, segment);
+    try {
+      if (lstatSync(current).isSymbolicLink()) return true;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+function trackedPaths(repoRoot) {
+  try {
+    const out = execFileSync("git", ["ls-files", "-z", "--", "AGENTS.md", ".claude", ".outerlayer"], {
+      cwd: repoRoot,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 5e3
+    });
+    return new Set(out.split("\0").filter((path) => path !== ""));
+  } catch {
+    return void 0;
+  }
+}
+function isPin(text) {
+  try {
+    const value = JSON.parse(text);
+    if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+    const { schemaVersion, sha, ...rest } = value;
+    return Object.keys(rest).length === 0 && typeof schemaVersion === "number" && typeof sha === "string" && /^[0-9a-f]{40}$/.test(sha);
+  } catch {
+    return false;
+  }
+}
+function pinMayDiffer(repoRoot, args) {
+  try {
+    execFileSync("git", ["diff", "--quiet", ...args, "--", CONTEXT_PIN_FILENAME], { cwd: repoRoot, stdio: "ignore", timeout: 5e3 });
+    return false;
+  } catch {
+    return true;
+  }
+}
+function restorePin(repoRoot) {
+  try {
+    if (!isPin(readFileSync(join(repoRoot, CONTEXT_PIN_FILENAME), "utf8"))) return false;
+    if (pinMayDiffer(repoRoot, ["--cached"]) || !pinMayDiffer(repoRoot, [])) return false;
+    execFileSync("git", ["checkout", "--", CONTEXT_PIN_FILENAME], { cwd: repoRoot, stdio: "ignore", timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function pruneEmptyDirs(start, root) {
+  let current = start;
+  while (current !== root && current.startsWith(root)) {
+    try {
+      if (readdirSync(current).length > 0) return;
+      rmdirSync(current);
+    } catch {
+      return;
+    }
+    current = dirname(current);
+  }
+}
+function cleanupEarlierCopies(input) {
+  const { repoRoot, gitCommonDir } = input;
+  const result = { removedFiles: [], excludeRemoved: false, guardRemoved: false, pinRestored: false };
+  if (!hasEarlierCopies(gitCommonDir)) return result;
+  let complete = true;
+  try {
+    const manifest = readContextManifest(gitCommonDir);
+    if (manifest !== void 0) {
+      const tracked = trackedPaths(repoRoot);
+      if (tracked === void 0) return result;
+      const isTracked = (rel) => [...tracked].some((path) => path === rel || rel.startsWith(`${path}/`));
+      for (const rel of manifest.files) {
+        if (!isCopiedPath(rel) || isTracked(rel) || hasSymlinkComponent(repoRoot, rel)) continue;
+        const abs = join(repoRoot, rel);
+        if (!existsSync(abs)) continue;
+        try {
+          unlinkSync(abs);
+          result.removedFiles.push(rel);
+          pruneEmptyDirs(dirname(abs), repoRoot);
+        } catch {
+          complete = false;
+        }
+      }
+    }
+  } catch {
+    return result;
+  }
+  if (!complete) return result;
+  result.pinRestored = restorePin(repoRoot);
+  try {
+    result.guardRemoved = removePreCommitGuardHook(repoRoot).removed;
+    result.excludeRemoved = removeContextExcludes(gitCommonDir).changed;
+    removeContextManifest(gitCommonDir);
+  } catch {
+  }
+  return result;
+}
+
+export { cleanupEarlierCopies };

package/dist/{claude-launcher-YVXI76NX.js → claude-launcher-J5M44PFS.js}

@@ -2,6 +2,7 @@
 import { createRequire } from 'node:module';
 import { versionAtLeast, MINIMUM_CLAUDE_VERSION, SHIM_SCRIPT, CONTROL_PLANE_DIR_VARIABLE } from './chunk-G2YNJIGF.js';
 export { MINIMUM_CLAUDE_VERSION } from './chunk-G2YNJIGF.js';
+import { homeFromEnv } from './chunk-VNVZDWO3.js';
 import './chunk-Z5GEFMRW.js';
 import { spawnSync, execFileSync, spawn } from 'child_process';
 import { existsSync, accessSync, constants, statSync, readFileSync } from 'fs';
@@ -20,7 +21,7 @@ function readDeliveryRecord(cwd) {
   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 } };
+      return { kind: "found", record: { repository: parsed.repository, sha: parsed.sha, dir: parsed.dir, launcher: parsed.launcher === true } };
     }
   } catch {
   }
@@ -72,17 +73,29 @@ async function runClaudeLauncher(args, deps = {}) {
     return 127;
   }
   const found = readDeliveryRecord(cwd);
-  if (found.kind === "none") return run(claude, args, env, cwd, stderr);
-  if (found.kind === "invalid") {
+  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;
   }
-  const { dir } = found.record;
-  if (!existsSync(dir)) {
-    stderr(`outerlayer claude: the control plane of ${found.record.repository} is not at ${dir}, so it cannot be attached
+  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;
+      return 1;
+    }
+  } else {
+    const { resolveLaunchPlane } = await import('./control-plane-launch-34LNRJWR.js');
+    const plane = await resolveLaunchPlane({ cwd, env, home: homeFromEnv(env), fetchImpl: deps.fetchImpl, stderr });
+    if (plane.kind === "none") return run(claude, 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)) {