@outerlayer/cli 0.2.0 → 0.4.1

package/dist/{chunk-65WXAANR.js → chunk-DVDEBNQJ.js}

@@ -5,7 +5,7 @@ import { mkdirSync, appendFileSync, readFileSync } from 'fs';
 import { join } from 'path';
 
 createRequire(import.meta.url);
-var HOW_TO_CREATE_AN_ITEM = "outerlayer work add";
+var HOW_TO_CREATE_AN_ITEM = "outerlayer work build --local";
 function parseWorkItemEnv(raw) {
   if (raw === void 0) return { reason: "OUTERLAYER_WORK is not set" };
   const value = raw.trim();
@@ -58,6 +58,21 @@ function launchedItemForSession(sessionId, home, readImpl = readLaunchSpool) {
   }
   return found;
 }
+function launchedItemsBySession(home, readImpl = readLaunchSpool) {
+  const items = /* @__PURE__ */ new Map();
+  const read = readImpl(launchesPath(home));
+  if (read.kind !== "read") return items;
+  for (const line of read.text.split("\n")) {
+    try {
+      const record = JSON.parse(line);
+      if (typeof record.sessionId === "string" && typeof record.item === "number") {
+        items.set(record.sessionId, record.item);
+      }
+    } catch {
+    }
+  }
+  return items;
+}
 function readLaunchSpoolState(home, readImpl = readLaunchSpool) {
   const ids = /* @__PURE__ */ new Set();
   const read = readImpl(launchesPath(home));
@@ -78,4 +93,4 @@ function readLaunchSpoolState(home, readImpl = readLaunchSpool) {
   return { ids, ...malformedLines > 0 ? { malformedLines } : {} };
 }
 
-export { appendLaunchRecord, launchStatusIsDecisive, launchedItemForSession, launchesPath, parseWorkItemEnv, readLaunchSpoolState };
+export { appendLaunchRecord, launchStatusIsDecisive, launchedItemForSession, launchedItemsBySession, launchesPath, parseWorkItemEnv, readLaunchSpoolState };

package/dist/{chunk-TFUIDMOB.js → chunk-EABW6AJQ.js}

@@ -30,5 +30,16 @@ function writeCloudConfig(config, home = homeFromEnv()) {
   } catch {
   }
 }
+function removeCloudConfigKeys(keys, home = homeFromEnv()) {
+  const path = cloudConfigPath(home);
+  if (!existsSync(path)) return;
+  const stored = { ...readCloudConfig(home) };
+  for (const key of keys) delete stored[key];
+  writeFileSync(path, JSON.stringify(stored, null, 2) + "\n", { mode: 384 });
+  try {
+    chmodSync(path, 384);
+  } catch {
+  }
+}
 
-export { cloudConfigPath, readCloudConfig, writeCloudConfig };
+export { cloudConfigPath, readCloudConfig, removeCloudConfigKeys, writeCloudConfig };

package/dist/{chunk-KFYJV2ZG.js → chunk-EMY4I27X.js}

@@ -7975,4 +7975,4 @@ function normalizeRepoName(repo) {
 var CONTEXT_PIN_FILENAME = ".outerlayer-pin.json";
 var CONTEXT_PIN_SCHEMA_VERSION = 1;
 
-export { CONTEXT_PIN_FILENAME, CONTEXT_PIN_SCHEMA_VERSION, CONTEXT_SOURCE_CONFIG_PATH, classifyTree, emitTree, generatedHeaderSource, normalizePath, normalizeRepoName, parseGoverns, parseOuterlayerConfig };
+export { CONTEXT_PIN_FILENAME, CONTEXT_PIN_SCHEMA_VERSION, CONTEXT_SOURCE_CONFIG_PATH, classifyTree, emitTree, generatedHeaderSource, normalizePath, normalizeRepoName, parseGoverns, parseOuterlayerConfig, splitRawFile };

package/dist/{chunk-NTTPJV35.js → chunk-F47JBIAW.js}

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { decodeWrappedCommand } from './chunk-R5KBGVII.js';
+import { recordReportedCost } from './chunk-BKO6JEZI.js';
+import { decodeWrappedCommand } from './chunk-5QRP3MVS.js';
 import { homeFromEnv } from './chunk-VNVZDWO3.js';
 import { readFileSync } from 'fs';
 import { spawn } from 'child_process';
@@ -133,6 +134,7 @@ async function runStatuslineFast(args, opts = {}) {
     const now = (opts.now ?? Date.now)();
     const stdinText = (opts.read ?? readStdin)();
     const stdin = parseStatuslineStdin(stdinText);
+    recordReportedCost(home, stdin.session_id, stdin.cost?.total_cost_usd);
     const state = readStatuslineState(home);
     const ourLine = renderStatusline(stdin, state, now);
     const { wrapId } = parseStatuslineArgs(args);

package/dist/chunk-F6GFZXZ3.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+
+createRequire(import.meta.url);
+
+// src/runner/container/disk.ts
+var UNITS = { "": 1, k: 1024, m: 1024 ** 2, g: 1024 ** 3 };
+function parseSize(text) {
+  const match = /^(\d+(?:\.\d+)?)([kKmMgG]?)$/.exec(text);
+  if (match === null) return void 0;
+  const bytes = Number(match[1]) * UNITS[match[2].toLowerCase()];
+  return bytes > 0 ? bytes : void 0;
+}
+function parseDuKilobytes(output) {
+  const match = /^(\d+)\s/.exec(output);
+  return match === null ? void 0 : Number(match[1]);
+}
+function exceedsDisk(usedKilobytes, limit) {
+  const bytes = parseSize(limit);
+  return usedKilobytes * 1024 > (bytes ?? Number.POSITIVE_INFINITY);
+}
+
+// src/runner/allow-hosts.ts
+var MAX_ALLOW_HOSTS = 500;
+var LABEL = /^(?!-)[a-z0-9-]{1,63}(?<!-)$/;
+var IPV4 = /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/;
+function isAddress(text) {
+  if (IPV4.test(text)) return true;
+  try {
+    new URL(`http://[${text}]/`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isHostName(text) {
+  const labels = text.split(".");
+  return text.length <= 253 && labels.every((label) => LABEL.test(label)) && !/^\d+$/.test(labels.at(-1));
+}
+function allowHostProblem(entry) {
+  if (typeof entry !== "string") return "is not a string";
+  const text = entry.toLowerCase();
+  if (isAddress(text)) return void 0;
+  if (text.startsWith("*.")) {
+    const domain = text.slice(2);
+    if (!isHostName(domain)) return "is not a host name after *.";
+    if (!domain.includes(".")) return "is too broad: a pattern needs a domain with at least two labels after *.";
+    return void 0;
+  }
+  return isHostName(text) ? void 0 : "is not a host name, a *. pattern or an IP address";
+}
+function hostAllowed(host, allowHosts) {
+  const name = host.toLowerCase().replace(/\.$/, "");
+  return allowHosts.some((entry) => {
+    const pattern = entry.toLowerCase();
+    return pattern.startsWith("*.") ? name.endsWith(pattern.slice(1)) : name === pattern;
+  });
+}
+
+export { MAX_ALLOW_HOSTS, allowHostProblem, exceedsDisk, hostAllowed, parseDuKilobytes, parseSize };

package/dist/{chunk-YOOSBOKS.js → chunk-F7CU5ABH.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { decodeWrappedCommand } from './chunk-R5KBGVII.js';
+import { decodeWrappedCommand } from './chunk-5QRP3MVS.js';
 import { homeFromEnv } from './chunk-VNVZDWO3.js';
 import { readFileSync, mkdirSync, appendFileSync, writeFileSync } from 'fs';
 import { spawn } from 'child_process';

package/dist/{emit-cmd-TWSYYEZI.js → chunk-H5NCNVDA.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { emitTree, parseOuterlayerConfig, classifyTree, generatedHeaderSource, CONTEXT_PIN_FILENAME, normalizePath } from './chunk-KFYJV2ZG.js';
-import './chunk-Z5GEFMRW.js';
+import { maintainedFilesForExistingSkills, loadMaintainedFiles, writeMaintainedFiles } from './chunk-WO2BXCTQ.js';
+import { emitTree, parseOuterlayerConfig, classifyTree, generatedHeaderSource, CONTEXT_PIN_FILENAME, normalizePath } from './chunk-EMY4I27X.js';
 import { existsSync, readFileSync, mkdirSync, writeFileSync, copyFileSync, readdirSync } from 'fs';
 import { join, dirname, relative, sep } from 'path';
 
@@ -53,19 +53,21 @@ function walk(dir, repoRoot, insideOuterlayer, out) {
     }
   }
 }
-function buildEmitInput(repoRoot, targets) {
-  const discovered = discoverOuterlayerPaths(repoRoot);
+function buildEmitInput(repoRoot, targets, maintained) {
+  const bundled = new Map(maintained.map((f) => [f.path, f.content]));
+  const discovered = [.../* @__PURE__ */ new Set([...discoverOuterlayerPaths(repoRoot), ...bundled.keys()])].sort();
   const { entries } = classifyTree(discovered);
   const classified = new Set(entries.map((e) => e.path));
   const contents = /* @__PURE__ */ new Map();
   for (const entry of entries) {
     if (!CONTENT_KINDS.has(entry.kind)) continue;
-    contents.set(entry.path, readFileSync(join(repoRoot, entry.path), "utf8"));
+    contents.set(entry.path, bundled.get(entry.path) ?? readFileSync(join(repoRoot, entry.path), "utf8"));
   }
   const assetPaths = discovered.filter((p) => !classified.has(p));
   return { input: { entries, contents, assetPaths, targets }, sourcePaths: classified };
 }
-function writeOutputs(repoRoot, result) {
+function writeOutputs(repoRoot, result, maintained) {
+  const changedMaintained = writeMaintainedFiles(repoRoot, maintained);
   const files = [];
   for (const file of result.files) {
     const abs = join(repoRoot, file.path);
@@ -80,11 +82,15 @@ function writeOutputs(repoRoot, result) {
     copyFileSync(join(repoRoot, copy.fromSourcePath), abs);
     copies.push(copy.toPath);
   }
-  return { files, copies };
+  return { files, copies, maintained: [...changedMaintained.created, ...changedMaintained.rewritten] };
 }
-function renderSuccess(targets, files, copies) {
+function renderSuccess(targets, files, copies, maintained) {
   const copySuffix = copies.length > 0 ? `, ${copies.length} ${copies.length === 1 ? "copy" : "copies"}` : "";
-  return `${GREEN}\u2713${RESET} emitted ${files.length} file${files.length === 1 ? "" : "s"}${copySuffix} for ${DIM}${targets.join(", ")}${RESET}`;
+  const lines = [
+    `${GREEN}\u2713${RESET} emitted ${files.length} file${files.length === 1 ? "" : "s"}${copySuffix} for ${DIM}${targets.join(", ")}${RESET}`
+  ];
+  for (const path of maintained) lines.push(`  ${DIM}updated ${path} to this CLI's version${RESET}`);
+  return lines.join("\n");
 }
 function renderFailure(errors) {
   const lines = [`${RED}\u2717${RESET} emit failed \u2014 nothing written`];
@@ -150,17 +156,48 @@ function findOrphans(repoRoot, computedFiles, sourcePaths) {
   }
   return orphans;
 }
+function withholdKept(repoRoot, result, keep) {
+  if (keep === void 0) return { result, kept: [] };
+  const kept = [];
+  const files = result.files.filter((file) => {
+    const abs = join(repoRoot, file.path);
+    if (!existsSync(abs)) return true;
+    const existing = readFileSync(abs, "utf8");
+    if (existing === file.content || !keep({ kind: "file", path: file.path, existing, content: file.content })) return true;
+    kept.push(file.path);
+    return false;
+  });
+  const copies = result.copies.filter((copy) => {
+    const abs = join(repoRoot, copy.toPath);
+    if (!existsSync(abs)) return true;
+    const src = join(repoRoot, copy.fromSourcePath);
+    if (existsSync(src) && readFileSync(abs).equals(readFileSync(src))) return true;
+    if (!keep({ kind: "copy", path: copy.toPath, source: copy.fromSourcePath })) return true;
+    kept.push(copy.toPath);
+    return false;
+  });
+  return { result: { ...result, files, copies }, kept: kept.sort() };
+}
 function runEmit(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
   if (!existsSync(cwd)) throw new EmitError(`no such directory: ${cwd}`);
   const targets = resolveTargetsFromConfig(cwd);
-  const built = buildEmitInput(cwd, targets);
-  const result = emitTree(built.input);
+  const maintained = maintainedFilesForExistingSkills(cwd, loadMaintainedFiles());
+  const built = buildEmitInput(cwd, targets, maintained);
+  const emitted = emitTree(built.input);
+  const { result, kept } = withholdKept(cwd, emitted, opts.keep);
   const hasErrors = result.errors.length > 0;
-  if (opts.check) return runCheck(cwd, opts, targets, result, hasErrors, built.sourcePaths);
-  const written = hasErrors ? { files: [], copies: [] } : writeOutputs(cwd, result);
+  if (opts.check) return runCheck(cwd, opts, targets, result, hasErrors, built.sourcePaths, maintained, kept);
+  const written = hasErrors ? { files: [], copies: [], maintained: [] } : writeOutputs(cwd, result, maintained);
   const exitCode = hasErrors ? 1 : 0;
-  const output = opts.json ? JSON.stringify({ targets, files: written.files, copies: written.copies, warnings: result.warnings, errors: result.errors }) : hasErrors ? renderFailure(result.errors) : renderSuccess(targets, written.files, written.copies);
+  const output = opts.json ? JSON.stringify({
+    targets,
+    files: written.files,
+    copies: written.copies,
+    maintained: written.maintained,
+    warnings: result.warnings,
+    errors: result.errors
+  }) : hasErrors ? renderFailure(result.errors) : renderSuccess(targets, written.files, written.copies, written.maintained);
   if (!opts.quiet) {
     if (opts.json) {
       process.stdout.write(output + "\n");
@@ -172,11 +209,25 @@ function runEmit(opts = {}) {
 `);
     }
   }
-  return { targets, files: written.files, copies: written.copies, warnings: result.warnings, errors: result.errors, output, exitCode };
+  return {
+    targets,
+    files: written.files,
+    copies: written.copies,
+    maintained: written.maintained,
+    kept,
+    warnings: result.warnings,
+    errors: result.errors,
+    output,
+    exitCode
+  };
 }
-function runCheck(cwd, opts, targets, result, hasErrors, sourcePaths) {
+function runCheck(cwd, opts, targets, result, hasErrors, sourcePaths, maintained, kept) {
   const drift = [];
   if (!hasErrors) {
+    for (const file of maintained) {
+      const d = compareFile(cwd, file.path, file.content);
+      if (d) drift.push(d);
+    }
     const computedFiles = new Set(result.files.map((f) => f.path));
     for (const file of result.files) {
       const d = compareFile(cwd, file.path, file.content);
@@ -202,7 +253,7 @@ function runCheck(cwd, opts, targets, result, hasErrors, sourcePaths) {
 `);
     }
   }
-  return { targets, files: [], copies: [], warnings: result.warnings, errors: result.errors, drift, output, exitCode };
+  return { targets, files: [], copies: [], maintained: [], kept, warnings: result.warnings, errors: result.errors, drift, output, exitCode };
 }
 
 export { EmitError, runEmit };