@outerlayer/cli 0.1.1 → 0.4.0

package/dist/{context-materialize-J6CRQ7O7.js → chunk-XDDW4FRS.js}

@@ -1,17 +1,55 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { readPin, pinExists, writeDegraded, writeSourceCache, SOURCE_CACHE_TTL_RETRY_MS, SOURCE_CACHE_TTL_SUCCESS_MS, readContextManifest, isLastCheckFresh, manifestFilesPresent, readDegraded, touchLastCheck, clearDegraded, writeContextManifest, writePinIfChanged, readSourceCache, isSourceCacheFresh } from './chunk-A3WLZX2F.js';
-import { parseGoverns, normalizeRepoName, CONTEXT_SOURCE_CONFIG_PATH } from './chunk-KFYJV2ZG.js';
+import { readPin, pinExists, readBuildHold, readContextManifest, manifestFilesPresent, writeDegraded, writeSourceCache, SOURCE_CACHE_TTL_RETRY_MS, SOURCE_CACHE_TTL_SUCCESS_MS, isLastCheckFresh, readDegraded, touchLastCheck, clearDegraded, writeContextManifest, writePinIfChanged, readSourceCache, isSourceCacheFresh } from './chunk-WIOZAJ2W.js';
+import { loadMaintainedFiles, writeMaintainedFiles } from './chunk-WO2BXCTQ.js';
+import { parseGoverns, normalizeRepoName, CONTEXT_SOURCE_CONFIG_PATH, parseOuterlayerConfig, classifyTree, emitTree } from './chunk-EMY4I27X.js';
 import { appendContextProvenance } from './chunk-ZJSNLVCE.js';
-import { ensureContextExcludes, ensurePreCommitGuardHook } from './chunk-IWIUYLDR.js';
-import { readCloudConfig } from './chunk-TFUIDMOB.js';
+import { defaultFetch } from './chunk-BCLJSQCV.js';
+import { resolveGatewayCredentials } from './chunk-BOLTI6LR.js';
+import { ensureContextExcludes, ensurePreCommitGuardHook } from './chunk-XCCLFVXM.js';
 import { homeFromEnv } from './chunk-VNVZDWO3.js';
-import './chunk-Z5GEFMRW.js';
 import { execFileSync } from 'child_process';
-import { existsSync, mkdirSync, writeFileSync, chmodSync, unlinkSync, readdirSync, rmSync, lstatSync } from 'fs';
-import { isAbsolute, join, dirname, relative } from 'path';
+import { lstatSync, existsSync, mkdirSync, writeFileSync, chmodSync, unlinkSync, readdirSync, rmSync, readFileSync, copyFileSync } from 'fs';
+import { join, isAbsolute, dirname, relative } from 'path';
 
 createRequire(import.meta.url);
+var CONFIG_PATH = ".outerlayer/config.json";
+var CONTENT_KINDS = /* @__PURE__ */ new Set(["skill", "skill-reference"]);
+function overlayMaintainedSkills(repoRoot, unsafe) {
+  const sources = loadMaintainedFiles().filter((file) => !unsafe(file.path));
+  writeMaintainedFiles(repoRoot, sources);
+  const paths = sources.map((file) => file.path);
+  const configAbs = join(repoRoot, CONFIG_PATH);
+  if (!existsSync(configAbs)) return paths;
+  const config = parseOuterlayerConfig(readFileSync(configAbs, "utf8"));
+  if (!config.ok || !config.config) return paths;
+  const { entries } = classifyTree(sources.map((file) => file.path));
+  const input = {
+    entries,
+    contents: new Map(entries.filter((e) => CONTENT_KINDS.has(e.kind)).map((e) => [e.path, sources.find((f) => f.path === e.path).content])),
+    assetPaths: [],
+    targets: config.config.targets
+  };
+  const compiled = emitTree(input);
+  if (compiled.errors.length > 0) return paths;
+  for (const file of compiled.files) {
+    if (unsafe(file.path)) continue;
+    const abs = join(repoRoot, file.path);
+    mkdirSync(dirname(abs), { recursive: true });
+    if (!existsSync(abs) || readFileSync(abs, "utf8") !== file.content) writeFileSync(abs, file.content);
+    paths.push(file.path);
+  }
+  for (const copy of compiled.copies) {
+    if (unsafe(copy.toPath)) continue;
+    const abs = join(repoRoot, copy.toPath);
+    mkdirSync(dirname(abs), { recursive: true });
+    copyFileSync(join(repoRoot, copy.fromSourcePath), abs);
+    paths.push(copy.toPath);
+  }
+  return paths;
+}
+
+// src/context-materialize.ts
 var defaultGitRunner = (args, opts) => {
   try {
     const stdout = execFileSync("git", args, {
@@ -54,8 +92,11 @@ function gitText(git, cwd, args, timeoutMs) {
 var NOT_GOVERNED_MESSAGE = "this repository's control plane no longer governs it";
 var ADOPTION_MESSAGE = "committed context files shadow the control plane \u2014 remove them in a commit";
 var CANNOT_IDENTIFY_MESSAGE = "this repository is governed, but the control plane cannot be identified \u2014 check OuterLayer connectivity/config";
-var DESIGNATION_AUTH_REJECTED_MESSAGE = "the OuterLayer API key was rejected (401/403) \u2014 check apiKey in ~/.outerlayer/config.json";
+function designationAuthRejectedMessage(credential) {
+  return credential.startsWith("olu_") ? "the OuterLayer login was rejected (401/403) \u2014 run `outerlayer login` to sign in again" : "the OuterLayer API key was rejected (401/403) \u2014 check apiKey in ~/.outerlayer/config.json";
+}
 var PARTIAL_WRITE_MESSAGE = "control-plane content could not be fully written \u2014 running on previous context";
+var OVERLAY_FAILED_MESSAGE = "control-plane content was written but the maintained skills could not be refreshed \u2014 retrying next session";
 var COMMIT_GUARD_FOREIGN_NOT_INSTALLED_MESSAGE = "the materialized-context commit guard is NOT installed \u2014 a pre-commit hook this clone did not write occupies that slot \u2014 resolve the conflict or run `outerlayer hooks install-git`";
 var COMMIT_GUARD_HOOKSPATH_NOT_INSTALLED_MESSAGE = "the materialized-context commit guard is NOT installed \u2014 hooks are managed via core.hooksPath, which this clone never writes to automatically \u2014 adopt it yourself: `outerlayer hooks install-git --print`";
 function guardNotInstalledMessage(guard) {
@@ -100,7 +141,7 @@ async function materializeContext(deps) {
   const home = deps.home ?? homeFromEnv();
   const now = deps.now ?? Date.now;
   const git = deps.git ?? defaultGitRunner;
-  const fetchImpl = deps.fetchImpl ?? fetch;
+  const fetchImpl = deps.fetchImpl ?? defaultFetch;
   const repoRoot = gitText(git, deps.cwd, ["rev-parse", "--show-toplevel"], 2e3);
   if (repoRoot === void 0) {
     return { status: "not-a-repo", sha: null, verification: "none" };
@@ -125,34 +166,53 @@ async function materializeContext(deps) {
     clearDegraded(gitCommonDir);
     return { status: "self", sha: null, verification: "none" };
   };
+  const hold = readBuildHold(gitCommonDir);
+  if (hold !== void 0) {
+    const heldManifest = readContextManifest(gitCommonDir);
+    if (heldManifest !== void 0 && heldManifest.sha === hold.sha && pin?.sha === hold.sha && manifestFilesPresent(repoRoot, heldManifest)) {
+      ensureContextExcludes(gitCommonDir);
+      recordMaintainedOverlay(repoRoot, gitCommonDir, heldManifest);
+      const guardMessage2 = guardNotInstalledMessage(ensurePreCommitGuardHook(repoRoot, gitCommonDir));
+      record(hold.sha, "verified", hold.repository, hold.ref);
+      return {
+        status: "debounced",
+        sha: hold.sha,
+        verification: "verified",
+        ...guardMessage2 ? { message: guardMessage2 } : {}
+      };
+    }
+  }
   const ownRepoName = deriveOwnRepoName(git, repoRoot);
   if (ownRepoName === void 0) {
     return selfOutcome();
   }
-  const designation = await resolveDesignation({ git, fetchImpl, home, now, gitCommonDir, ownRepoName });
+  const designation = await resolveDesignation({ git, fetchImpl, home, cloud: deps.cloud, now, gitCommonDir, ownRepoName, repoRoot });
+  const answered = { designation: "answered" };
   if (designation.status === "self") {
-    return selfOutcome();
+    return { ...selfOutcome(), ...answered };
   }
   if (designation.status === "unknown") {
-    const message = designation.authRejected ? DESIGNATION_AUTH_REJECTED_MESSAGE : CANNOT_IDENTIFY_MESSAGE;
+    const message = designation.authRejected ?? CANNOT_IDENTIFY_MESSAGE;
     if (hasPin) {
       writeDegraded(gitCommonDir, { at: new Date(now()).toISOString(), kind: "designation-unverified", message });
       record(null, "none");
-      return { status: "designation-unverified", message, sha: null, verification: "none" };
+      return { status: "designation-unverified", message, sha: null, verification: "none", designation: "unknown" };
     }
     if (designation.authRejected) {
       writeDegraded(gitCommonDir, { at: new Date(now()).toISOString(), kind: "designation-unverified", message });
     }
     writeSourceCache(gitCommonDir, { checkedAt: new Date(now()).toISOString(), status: "self", ttlMs: SOURCE_CACHE_TTL_RETRY_MS });
-    return { status: "self", sha: null, verification: "none" };
+    return { status: "self", sha: null, verification: "none", designation: "unknown", ...designation.authRejected ? { authRejected: true } : {} };
   }
   let repository;
   let ref;
   let unverifiedIdentity;
   let preFetched;
+  let unreadableCandidates = [];
   if (designation.status === "candidates") {
     const sortedCandidates = [...designation.candidates].sort((a, b) => a.repository.localeCompare(b.repository));
     const claimants = [];
+    const unfetched = [];
     for (const candidate of sortedCandidates) {
       const candidateUrl = deps.resolveControlPlaneUrl ? deps.resolveControlPlaneUrl(candidate.repository, candidate.ref, repoRoot) : buildControlPlaneUrl(git, repoRoot, candidate.repository);
       const candidateHost = parseRemoteHost(candidateUrl).host || "unknown-host";
@@ -162,9 +222,15 @@ async function materializeContext(deps) {
         cwd: candidateCacheDir,
         timeoutMs: 1e4
       });
-      if (!candidateFetch.ok) continue;
+      if (!candidateFetch.ok) {
+        unfetched.push(candidate.repository);
+        continue;
+      }
       const candidateSha = gitText(git, candidateCacheDir, ["rev-parse", candidateLocalRef], 2e3);
-      if (candidateSha === void 0) continue;
+      if (candidateSha === void 0) {
+        unfetched.push(candidate.repository);
+        continue;
+      }
       const candidateConfig = readBlobAtPath(git, candidateCacheDir, candidateSha, CONTEXT_SOURCE_CONFIG_PATH);
       const candidateGoverns = candidateConfig === void 0 ? { governs: [] } : parseGoverns(candidateConfig);
       const candidateGovernsList = "error" in candidateGoverns ? [] : candidateGoverns.governs;
@@ -174,7 +240,7 @@ async function materializeContext(deps) {
     }
     if (claimants.length === 0) {
       writeSourceCache(gitCommonDir, { checkedAt: new Date(now()).toISOString(), status: "self", ttlMs: SOURCE_CACHE_TTL_SUCCESS_MS });
-      return selfOutcome();
+      return { ...selfOutcome(), ...answered, ...unfetched.length > 0 ? { unfetched } : {} };
     }
     if (claimants.length > 1) {
       const names = claimants.map((c) => c.repository).sort();
@@ -186,6 +252,7 @@ async function materializeContext(deps) {
       record(lastGood, verification);
       return { status: "conflict", message, sha: lastGood, verification };
     }
+    unreadableCandidates = unfetched;
     const winner = claimants[0];
     writeSourceCache(gitCommonDir, {
       checkedAt: new Date(now()).toISOString(),
@@ -227,6 +294,7 @@ async function materializeContext(deps) {
       const degraded = readDegraded(gitCommonDir);
       const verification = degraded ? "unverified" : "verified";
       ensureContextExcludes(gitCommonDir);
+      recordMaintainedOverlay(repoRoot, gitCommonDir, manifest);
       const guardMessage2 = guardNotInstalledMessage(ensurePreCommitGuardHook(repoRoot, gitCommonDir));
       record(manifest.sha, verification, repository, ref);
       return {
@@ -255,6 +323,7 @@ async function materializeContext(deps) {
         touchLastCheck(gitCommonDir, now());
         clearOrFlagIdentity();
         ensureContextExcludes(gitCommonDir);
+        recordMaintainedOverlay(repoRoot, gitCommonDir, manifest);
         const guardMessage2 = guardNotInstalledMessage(ensurePreCommitGuardHook(repoRoot, gitCommonDir));
         writeSourceCache(gitCommonDir, { checkedAt: new Date(now()).toISOString(), status: "governed", repository, ref, ttlMs: SOURCE_CACHE_TTL_SUCCESS_MS });
         record(remoteSha, "verified", repository, ref);
@@ -335,14 +404,36 @@ async function materializeContext(deps) {
   if (!writeResult.ok) {
     return partialWrite();
   }
-  const deleteResult = manifest ? deleteRemovedFiles(repoRoot, manifest.files, writeResult.writtenPaths) : { skipped: [] };
+  let overlayPaths = [];
+  let overlayFailed = false;
+  try {
+    overlayPaths = overlayMaintainedSkills(repoRoot, (rel) => hasSymlinkComponent(repoRoot, rel));
+  } catch {
+    overlayFailed = true;
+  }
+  const writtenPaths = [.../* @__PURE__ */ new Set([...writeResult.writtenPaths, ...overlayPaths])];
+  const deleteResult = manifest ? deleteRemovedFiles(repoRoot, manifest.files, writtenPaths) : { skipped: [] };
+  if (overlayFailed && deleteResult.skipped.length === 0) {
+    writeContextManifest(gitCommonDir, { schemaVersion: 1, sha, files: writtenPaths, materializedAt: new Date(now()).toISOString() });
+    writeDegraded(gitCommonDir, {
+      at: new Date(now()).toISOString(),
+      kind: "unreachable",
+      message: OVERLAY_FAILED_MESSAGE,
+      repository,
+      ref,
+      lastGoodSha: sha
+    });
+    if (!evidenced) return { status: "unreachable", sha: null, verification: "none" };
+    record(sha, "unverified", repository, ref);
+    return { status: "unreachable", message: OVERLAY_FAILED_MESSAGE, sha, verification: "unverified" };
+  }
   if (deleteResult.skipped.length > 0) {
     return partialWrite();
   }
   const newManifest = {
     schemaVersion: 1,
     sha,
-    files: writeResult.writtenPaths,
+    files: writtenPaths,
     materializedAt: new Date(now()).toISOString()
   };
   writeContextManifest(gitCommonDir, newManifest);
@@ -357,23 +448,40 @@ async function materializeContext(deps) {
     status: "materialized",
     sha,
     verification: "verified",
-    ...guardMessage ? { message: guardMessage } : {}
+    ...guardMessage ? { message: guardMessage } : {},
+    ...unreadableCandidates.length > 0 ? { unfetched: unreadableCandidates } : {}
   };
 }
+function recordMaintainedOverlay(repoRoot, gitCommonDir, manifest) {
+  let overlayPaths;
+  try {
+    overlayPaths = overlayMaintainedSkills(repoRoot, (rel) => hasSymlinkComponent(repoRoot, rel));
+  } catch {
+    return;
+  }
+  const known = new Set(manifest.files);
+  const added = overlayPaths.filter((path) => !known.has(path));
+  if (added.length > 0) writeContextManifest(gitCommonDir, { ...manifest, files: [...manifest.files, ...added] });
+}
 async function resolveDesignation(ctx) {
   const cache = readSourceCache(ctx.gitCommonDir);
   if (cache && isSourceCacheFresh(cache, ctx.now())) {
     return cache.status === "governed" && cache.repository && cache.ref ? { status: "governed", repository: cache.repository, ref: cache.ref } : { status: "self" };
   }
-  let authRejected = false;
-  const config = readCloudConfig(ctx.home);
-  if (config.url && config.apiKey && config.appId) {
+  let authRejected;
+  const destination = resolveGatewayCredentials({
+    home: ctx.home,
+    env: {},
+    cwd: ctx.repoRoot,
+    ...ctx.cloud === void 0 ? {} : { url: ctx.cloud.url, apiKey: ctx.cloud.apiKey, appId: ctx.cloud.appId }
+  });
+  if (destination.ok) {
     const sources = await fetchContextSource(
-      config,
+      { url: destination.url, apiKey: destination.credential, appId: destination.appId },
       ctx.ownRepoName,
       ctx.fetchImpl,
       () => {
-        authRejected = true;
+        authRejected = designationAuthRejectedMessage(destination.credential);
       }
     );
     if (sources !== void 0) {
@@ -586,4 +694,4 @@ function pruneEmptyDirs(dir, stopAt) {
   }
 }
 
-export { defaultGitRunner, materializeContext, parseOwnerRepo, parseRemoteHost };
+export { defaultGitRunner, hasSymlinkComponent, materializeContext, parseOwnerRepo, parseRemoteHost, resolveGitCommonDir };

package/dist/chunk-YYYXRJUW.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { runnerDir, RUNNER_DIR_MODE, RUNNER_FILE_MODE } from './chunk-ZM2IMMYN.js';
+import { readlinkSync, realpathSync, mkdirSync, unlinkSync, symlinkSync, renameSync, readFileSync, writeFileSync, rmSync, existsSync, readdirSync } from 'fs';
+import { join, basename, sep, resolve } from 'path';
+
+createRequire(import.meta.url);
+var PACKAGE_PATH = join("node_modules", "@outerlayer", "cli");
+var STAGING_PREFIX = ".staging-";
+function versionsDir(configPath) {
+  return join(runnerDir(configPath), "versions");
+}
+function versionDir(configPath, version) {
+  return join(versionsDir(configPath), version);
+}
+function stagingDir(configPath, version) {
+  return join(versionsDir(configPath), `${STAGING_PREFIX}${version}`);
+}
+function currentLink(configPath) {
+  return join(runnerDir(configPath), "current");
+}
+function markerPath(configPath) {
+  return join(runnerDir(configPath), "update-marker.json");
+}
+function packageRootIn(dir) {
+  return join(dir, PACKAGE_PATH);
+}
+function entryIn(dir) {
+  return join(packageRootIn(dir), "dist", "index.js");
+}
+function currentVersion(configPath) {
+  try {
+    return basename(readlinkSync(currentLink(configPath)));
+  } catch {
+    return void 0;
+  }
+}
+function isInLayout(configPath, entryPath) {
+  try {
+    const versions = realpathSync(versionsDir(configPath));
+    return realpathSync(entryPath).startsWith(`${versions}${sep}`);
+  } catch {
+    return false;
+  }
+}
+function startedThroughCurrent(configPath, entryPath) {
+  const parts = resolve(entryPath).split(sep);
+  const at = parts.lastIndexOf("current");
+  if (at <= 0 || parts.slice(at + 1).join(sep) !== join(PACKAGE_PATH, "dist", "index.js")) return false;
+  try {
+    return realpathSync(parts.slice(0, at).join(sep) || sep) === realpathSync(runnerDir(configPath));
+  } catch {
+    return false;
+  }
+}
+function switchCurrent(configPath, version) {
+  mkdirSync(runnerDir(configPath), { recursive: true, mode: RUNNER_DIR_MODE });
+  const temporary = `${currentLink(configPath)}.new`;
+  try {
+    unlinkSync(temporary);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  symlinkSync(versionDir(configPath, version), temporary);
+  renameSync(temporary, currentLink(configPath));
+}
+function readMarker(configPath) {
+  try {
+    const parsed = JSON.parse(readFileSync(markerPath(configPath), "utf8"));
+    if (typeof parsed.from !== "string" || typeof parsed.to !== "string") return void 0;
+    return { from: parsed.from, to: parsed.to, starts: typeof parsed.starts === "number" && Number.isInteger(parsed.starts) ? parsed.starts : 0 };
+  } catch {
+    return void 0;
+  }
+}
+function writeMarker(configPath, marker) {
+  mkdirSync(runnerDir(configPath), { recursive: true, mode: RUNNER_DIR_MODE });
+  const temporary = `${markerPath(configPath)}.tmp`;
+  writeFileSync(temporary, `${JSON.stringify(marker)}
+`, { mode: RUNNER_FILE_MODE });
+  renameSync(temporary, markerPath(configPath));
+}
+function removeMarker(configPath) {
+  rmSync(markerPath(configPath), { force: true });
+}
+function cleanVersions(configPath, keep) {
+  const dir = versionsDir(configPath);
+  if (!existsSync(dir)) return;
+  for (const name of readdirSync(dir)) {
+    if (keep.includes(name)) continue;
+    rmSync(join(dir, name), { recursive: true, force: true });
+  }
+}
+function execStartCommand(configPath, nodePath) {
+  return `${nodePath} ${join(currentLink(configPath), "node_modules", "@outerlayer", "cli", "dist", "index.js")} runner start --config ${configPath}`;
+}
+function execStartLine(configPath, nodePath) {
+  return `ExecStart=${execStartCommand(configPath, nodePath)}`;
+}
+
+export { cleanVersions, currentVersion, entryIn, execStartCommand, execStartLine, isInLayout, packageRootIn, readMarker, removeMarker, stagingDir, startedThroughCurrent, switchCurrent, versionDir, writeMarker };

package/dist/chunk-ZM2IMMYN.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { join, dirname } from 'path';
+
+createRequire(import.meta.url);
+var RUNNER_DIR_MODE = 448;
+var RUNNER_FILE_MODE = 384;
+function runnerDir(configPath) {
+  return join(dirname(configPath), "runner");
+}
+function hostKeyPath(configPath) {
+  return join(runnerDir(configPath), "host-key.pem");
+}
+function pidFilePath(configPath) {
+  return join(runnerDir(configPath), "runner.pid");
+}
+function jobsDir(configPath) {
+  return join(runnerDir(configPath), "jobs");
+}
+function jobDir(configPath, queue, item, claimId, attempt) {
+  const suffix = attempt === void 0 ? "" : `-${attempt}`;
+  return join(jobsDir(configPath), `${queue}-${item}-${claimId}${suffix}`);
+}
+function attemptStamp(at) {
+  return at.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+}
+function imagesDir(configPath) {
+  return join(runnerDir(configPath), "images");
+}
+function repoCacheDir(configPath, owner, name) {
+  return join(runnerDir(configPath), "repos", owner, name);
+}
+function buildsDir(configPath) {
+  return join(runnerDir(configPath), "builds");
+}
+function buildDir(configPath, buildId) {
+  return join(buildsDir(configPath), buildId);
+}
+function ghConfigDir(buildDirPath) {
+  return join(buildDirPath, "gh");
+}
+function mirrorDir(runnerDirPath, owner, name) {
+  return join(runnerDirPath, "mirrors", owner, `${name}.git`);
+}
+function spoolDir(runnerDirPath) {
+  return join(runnerDirPath, "spool");
+}
+function contextHomeDir(configPath) {
+  return join(runnerDir(configPath), "context-home");
+}
+function stagedContextDir(buildDirPath) {
+  return join(buildDirPath, "context");
+}
+function runnerDirOfBuild(buildDirPath) {
+  return dirname(dirname(buildDirPath));
+}
+function vmDir(runnerDirPath) {
+  return join(runnerDirPath, "vm");
+}
+function vmAssetsDir(runnerDirPath) {
+  return join(vmDir(runnerDirPath), "assets");
+}
+function rootfsDir(runnerDirPath) {
+  return join(vmDir(runnerDirPath), "rootfs");
+}
+function rootfsPathFor(runnerDirPath, imageId) {
+  return join(rootfsDir(runnerDirPath), `${imageId.replace(/^sha256:/, "").replace(/[^A-Za-z0-9._-]/g, "_")}.ext4`);
+}
+function diskTemplatesDir(runnerDirPath) {
+  return join(vmDir(runnerDirPath), "templates");
+}
+function vsockPath(buildDirPath) {
+  return join(buildDirPath, "v.sock");
+}
+
+export { RUNNER_DIR_MODE, RUNNER_FILE_MODE, attemptStamp, buildDir, contextHomeDir, diskTemplatesDir, ghConfigDir, hostKeyPath, imagesDir, jobDir, jobsDir, mirrorDir, pidFilePath, repoCacheDir, rootfsDir, rootfsPathFor, runnerDir, runnerDirOfBuild, spoolDir, stagedContextDir, vmAssetsDir, vsockPath };

package/dist/chunk-ZMYPLFG3.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { C } from './chunk-YRYMNBGQ.js';
+import { resolvePackRoot, loadTemplateFiles, loadMaintainedFiles, TEMPLATE_SKILLS, skillDir, writeMaintainedFiles, MAINTAINED_SKILLS } from './chunk-WO2BXCTQ.js';
+import { resolvePackageVersion } from './chunk-RA3O54FC.js';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join, dirname } from 'path';
+
+createRequire(import.meta.url);
+var DEFAULT_TEMPLATE = "default";
+var POLICY_PATH = ".outerlayer/policy.yaml";
+var POLICY_CONTENT = "extends: outerlayer:recommended@v1\nreview: required\n";
+var StarterPackError = class extends Error {
+};
+function assertKnownTemplate(name) {
+  if (name !== DEFAULT_TEMPLATE) {
+    throw new StarterPackError(`unknown template "${name}" \u2014 the only template is "${DEFAULT_TEMPLATE}"`);
+  }
+}
+function installStarterPack(opts) {
+  const packRoot = opts.packRoot ?? resolvePackRoot();
+  const version = opts.version ?? resolvePackageVersion();
+  const templateFiles = loadTemplateFiles(packRoot, version);
+  const maintainedFiles = loadMaintainedFiles(packRoot, version);
+  const copied = [];
+  const kept = [];
+  for (const skill of TEMPLATE_SKILLS) {
+    if (existsSync(join(opts.repoRoot, skillDir(skill)))) {
+      kept.push(skill);
+      continue;
+    }
+    for (const file of templateFiles.filter((f) => f.skill === skill)) {
+      const abs = join(opts.repoRoot, file.path);
+      mkdirSync(dirname(abs), { recursive: true });
+      writeFileSync(abs, file.content);
+    }
+    copied.push(skill);
+  }
+  const written = writeMaintainedFiles(opts.repoRoot, maintainedFiles);
+  let policy = "kept";
+  const policyAbs = join(opts.repoRoot, POLICY_PATH);
+  if (!existsSync(policyAbs)) {
+    mkdirSync(dirname(policyAbs), { recursive: true });
+    writeFileSync(policyAbs, POLICY_CONTENT);
+    policy = "written";
+  }
+  return { copied, kept, maintained: [...written.created, ...written.rewritten], policy };
+}
+var skillFile = (skill) => `${skillDir(skill)}/SKILL.md`;
+function formatStarterPackOutput(result) {
+  const lines = [];
+  lines.push(`${C.green}\u2713${C.reset} Installed the starter skills in .outerlayer/skills/`, "");
+  lines.push("Yours to edit \u2014 copied once, never overwritten:");
+  for (const skill of TEMPLATE_SKILLS) {
+    lines.push(
+      result.kept.includes(skill) ? `  ${C.dim}kept${C.reset} ${skillDir(skill)}/ ${C.dim}(already exists, left exactly as it is)${C.reset}` : `  ${skillFile(skill)}`
+    );
+  }
+  lines.push("", "Rewritten on every emit \u2014 edits are overwritten by the installed CLI:");
+  for (const skill of MAINTAINED_SKILLS) lines.push(`  ${skillFile(skill)}`);
+  lines.push(
+    "",
+    result.policy === "written" ? `${C.green}\u2713${C.reset} Wrote ${POLICY_PATH} (extends the recommended checks, review required)` : `${C.dim}${POLICY_PATH} already exists \u2014 left as it is${C.reset}`,
+    "",
+    `Next: create .outerlayer/config.json naming your agent tools, for example {"targets": ["claude-code"]},`,
+    `then run ${C.yellow}outerlayer context emit${C.reset} to compile the skills into their native files.`
+  );
+  return lines.join("\n") + "\n";
+}
+
+export { StarterPackError, assertKnownTemplate, formatStarterPackOutput, installStarterPack };