@outerlayer/cli 0.2.0 → 0.4.1

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 };